src/gallium/state_trackers/egl/wayland/native_wayland.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.11
   4  *
   5  * Copyright (C) 2011 Benjamin Franzke <benjaminfranzke@googlemail.com>
   6  *
   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:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  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.
  24  */
  25
  26 #include "util/u_memory.h"
  27 #include "util/u_inlines.h"
  28
  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"
  34 #include "egllog.h"
  35
  36 #include "native_wayland.h"
  37
  38 static const struct native_event_handler *wayland_event_handler;
  39
  40 const static struct {
  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 },
  46 };
  47
  48 static const struct native_config **
  49 wayland_display_get_configs(struct native_display *ndpy, int *num_configs)
  50 {
  51    struct wayland_display *display = wayland_display(ndpy);
  52    const struct native_config **configs;
  53    int i;
  54
  55    if (!display->configs) {
  56       struct native_config *nconf;
  57
  58       display->num_configs = 0;
  59       display->configs = CALLOC(Elements(wayland_formats),
  60                                 sizeof(*display->configs));
  61       if (!display->configs)
  62          return NULL;
  63
  64       for (i = 0; i < Elements(wayland_formats); ++i) {
  65          if (!(display->formats & wayland_formats[i].flag))
  66             continue;
  67
  68          nconf = &display->configs[display->num_configs].base;
  69          nconf->buffer_mask =
  70             (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
  71             (1 << NATIVE_ATTACHMENT_BACK_LEFT);
  72
  73          nconf->window_bit = TRUE;
  74          nconf->pixmap_bit = TRUE;
  75
  76          nconf->color_format = wayland_formats[i].format;
  77          display->num_configs++;
  78       }
  79    }
  80
  81    configs = MALLOC(display->num_configs * sizeof(*configs));
  82    if (configs) {
  83       for (i = 0; i < display->num_configs; ++i)
  84          configs[i] = &display->configs[i].base;
  85       if (num_configs)
  86          *num_configs = display->num_configs;
  87    }
  88
  89    return configs;
  90 }
  91
  92 static int
  93 wayland_display_get_param(struct native_display *ndpy,
  94                           enum native_param_type param)
  95 {
  96    struct wayland_display *display = wayland_display(ndpy);
  97    int val;
  98
  99    switch (param) {
 100    case NATIVE_PARAM_PREMULTIPLIED_ALPHA:
 101       val = 1;
 102       break;
 103    case NATIVE_PARAM_USE_NATIVE_BUFFER:
 104    case NATIVE_PARAM_PRESERVE_BUFFER:
 105    case NATIVE_PARAM_MAX_SWAP_INTERVAL:
 106    default:
 107       val = 0;
 108       break;
 109    }
 110
 111    return val;
 112 }
 113
 114 static boolean
 115 wayland_display_get_pixmap_format(struct native_display *ndpy,
 116                                   EGLNativePixmapType pix,
 117                                   enum pipe_format *format)
 118 {
 119    /* all wl_egl_pixmaps are supported */
 120    *format = PIPE_FORMAT_NONE;
 121
 122    return TRUE;
 123 }
 124
 125 static void
 126 wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap)
 127 {
 128    struct pipe_resource *resource = egl_pixmap->driver_private;
 129
 130    assert(resource);
 131
 132    pipe_resource_reference(&resource, NULL);
 133    if (egl_pixmap->buffer) {
 134       wl_buffer_destroy(egl_pixmap->buffer);
 135       egl_pixmap->buffer = NULL;
 136    }
 137
 138    egl_pixmap->driver_private = NULL;
 139    egl_pixmap->destroy = NULL;
 140 }
 141
 142 static void
 143 wayland_pixmap_surface_initialize(struct wayland_surface *surface)
 144 {
 145    struct wayland_display *display = wayland_display(&surface->display->base);
 146    const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 147
 148    if (surface->pix->buffer != NULL)
 149       return;
 150
 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);
 155 }
 156
 157 static void
 158 wayland_release_pending_resource(void *data,
 159                                  struct wl_callback *callback,
 160                                  uint32_t time)
 161 {
 162    struct wayland_surface *surface = data;
 163
 164    wl_callback_destroy(callback);
 165
 166    /* FIXME: print internal error */
 167    if (!surface->pending_resource)
 168       return;
 169
 170    pipe_resource_reference(&surface->pending_resource, NULL);
 171 }
 172
 173 static const struct wl_callback_listener release_buffer_listener = {
 174    wayland_release_pending_resource
 175 };
 176
 177 static void
 178 wayland_window_surface_handle_resize(struct wayland_surface *surface)
 179 {
 180    struct wayland_display *display = surface->display;
 181    struct pipe_resource *front_resource;
 182    const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 183    int i;
 184
 185    front_resource = resource_surface_get_single_resource(surface->rsurf,
 186                                                          front_natt);
 187    if (resource_surface_set_size(surface->rsurf,
 188                                  surface->win->width, surface->win->height)) {
 189
 190       if (surface->pending_resource)
 191          wl_display_roundtrip(display->dpy);
 192
 193       if (front_resource) {
 194          struct wl_callback *callback;
 195
 196          surface->pending_resource = front_resource;
 197          front_resource = NULL;
 198
 199          callback = wl_display_sync(display->dpy);
 200          wl_callback_add_listener(callback, &release_buffer_listener, surface);
 201       }
 202
 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;
 207       }
 208
 209       surface->dx = surface->win->dx;
 210       surface->dy = surface->win->dy;
 211    }
 212    pipe_resource_reference(&front_resource, NULL);
 213 }
 214
 215 static boolean
 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)
 219 {
 220    struct wayland_surface *surface = wayland_surface(nsurf);
 221
 222    if (surface->type == WL_WINDOW_SURFACE)
 223       wayland_window_surface_handle_resize(surface);
 224
 225    if (!resource_surface_add_resources(surface->rsurf, attachment_mask |
 226                                        surface->attachment_mask))
 227       return FALSE;
 228
 229    if (textures)
 230       resource_surface_get_resources(surface->rsurf, textures, attachment_mask);
 231
 232    if (seq_num)
 233       *seq_num = surface->sequence_number;
 234
 235    resource_surface_get_size(surface->rsurf, (uint *) width, (uint *) height);
 236
 237    if (surface->type == WL_PIXMAP_SURFACE)
 238       wayland_pixmap_surface_initialize(surface);
 239
 240    return TRUE;
 241 }
 242
 243 static void
 244 wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time)
 245 {
 246    struct wayland_surface *surface = data;
 247
 248    surface->block_swap_buffers = FALSE;
 249
 250    wl_callback_destroy(callback);
 251 }
 252
 253 static const struct wl_callback_listener frame_listener = {
 254    wayland_frame_callback
 255 };
 256
 257 static INLINE void
 258 wayland_buffers_swap(struct wl_buffer **buffer,
 259                      enum wayland_buffer_type buf1,
 260                      enum wayland_buffer_type buf2)
 261 {
 262    struct wl_buffer *tmp = buffer[buf1];
 263    buffer[buf1] = buffer[buf2];
 264    buffer[buf2] = tmp;
 265 }
 266
 267 static boolean
 268 wayland_surface_swap_buffers(struct native_surface *nsurf)
 269 {
 270    struct wayland_surface *surface = wayland_surface(nsurf);
 271    struct wayland_display *display = surface->display;
 272    struct wl_callback *callback;
 273
 274    while (surface->block_swap_buffers)
 275       wl_display_iterate(display->dpy, WL_DISPLAY_READABLE);
 276
 277    surface->block_swap_buffers = TRUE;
 278
 279    callback = wl_surface_frame(surface->win->surface);
 280    wl_callback_add_listener(callback, &frame_listener, surface);
 281
 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);
 286
 287       wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK);
 288
 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);
 293
 294       wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT],
 295                         surface->dx, surface->dy);
 296
 297       resource_surface_get_size(surface->rsurf,
 298                                 (uint *) &surface->win->attached_width,
 299                                 (uint *) &surface->win->attached_height);
 300       surface->dx = 0;
 301       surface->dy = 0;
 302    }
 303
 304    surface->sequence_number++;
 305    wayland_event_handler->invalid_surface(&display->base,
 306                                           &surface->base,
 307                                           surface->sequence_number);
 308
 309    return TRUE;
 310 }
 311
 312 static boolean
 313 wayland_surface_present(struct native_surface *nsurf,
 314                         const struct native_present_control *ctrl)
 315 {
 316    struct wayland_surface *surface = wayland_surface(nsurf);
 317    uint width, height;
 318    boolean ret;
 319
 320    if (ctrl->preserve || ctrl->swap_interval)
 321       return FALSE;
 322
 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;
 326
 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;
 331          }
 332       }
 333
 334       surface->premultiplied_alpha = ctrl->premultiplied_alpha;
 335    }
 336
 337    switch (ctrl->natt) {
 338    case NATIVE_ATTACHMENT_FRONT_LEFT:
 339       ret = TRUE;
 340       break;
 341    case NATIVE_ATTACHMENT_BACK_LEFT:
 342       ret = wayland_surface_swap_buffers(nsurf);
 343       break;
 344    default:
 345       ret = FALSE;
 346       break;
 347    }
 348
 349    if (surface->type == WL_WINDOW_SURFACE) {
 350       resource_surface_get_size(surface->rsurf, &width, &height);
 351       wl_surface_damage(surface->win->surface, 0, 0, width, height);
 352    }
 353
 354    return ret;
 355 }
 356
 357 static void
 358 wayland_surface_wait(struct native_surface *nsurf)
 359 {
 360    /* no-op */
 361 }
 362
 363 static void
 364 wayland_surface_destroy(struct native_surface *nsurf)
 365 {
 366    struct wayland_surface *surface = wayland_surface(nsurf);
 367    enum wayland_buffer_type buffer;
 368
 369    for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
 370       if (surface->buffer[buffer])
 371          wl_buffer_destroy(surface->buffer[buffer]);
 372    }
 373
 374    resource_surface_destroy(surface->rsurf);
 375    FREE(surface);
 376 }
 377
 378
 379
 380 static struct native_surface *
 381 wayland_create_pixmap_surface(struct native_display *ndpy,
 382                               EGLNativePixmapType pix,
 383                               const struct native_config *nconf)
 384 {
 385    struct wayland_display *display = wayland_display(ndpy);
 386    struct wayland_surface *surface;
 387    struct wl_egl_pixmap *egl_pixmap = (struct wl_egl_pixmap *) pix;
 388    enum native_attachment natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 389    uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
 390       PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT;
 391
 392    surface = CALLOC_STRUCT(wayland_surface);
 393    if (!surface)
 394       return NULL;
 395
 396    surface->display = display;
 397
 398    surface->pending_resource = NULL;
 399    surface->type = WL_PIXMAP_SURFACE;
 400    surface->pix = egl_pixmap;
 401
 402    if (nconf)
 403       surface->color_format = nconf->color_format;
 404    else /* FIXME: derive format from wl_visual */
 405       surface->color_format = PIPE_FORMAT_B8G8R8A8_UNORM;
 406
 407    surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT);
 408
 409    surface->rsurf = resource_surface_create(display->base.screen,
 410                                             surface->color_format, bind);
 411
 412    if (!surface->rsurf) {
 413       FREE(surface);
 414       return NULL;
 415    }
 416
 417    resource_surface_set_size(surface->rsurf,
 418                              egl_pixmap->width, egl_pixmap->height);
 419
 420    /* the pixmap is already allocated, so import it */
 421    if (surface->pix->buffer != NULL)
 422       resource_surface_import_resource(surface->rsurf, natt,
 423                                        surface->pix->driver_private);
 424
 425    surface->base.destroy = wayland_surface_destroy;
 426    surface->base.present = wayland_surface_present;
 427    surface->base.validate = wayland_surface_validate;
 428    surface->base.wait = wayland_surface_wait;
 429
 430    return &surface->base;
 431 }
 432
 433
 434 static struct native_surface *
 435 wayland_create_window_surface(struct native_display *ndpy,
 436                               EGLNativeWindowType win,
 437                               const struct native_config *nconf)
 438 {
 439    struct wayland_display *display = wayland_display(ndpy);
 440    struct wayland_config *config = wayland_config(nconf);
 441    struct wayland_surface *surface;
 442    uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
 443       PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT;
 444
 445    surface = CALLOC_STRUCT(wayland_surface);
 446    if (!surface)
 447       return NULL;
 448
 449    surface->display = display;
 450    surface->color_format = config->base.color_format;
 451
 452    surface->win = (struct wl_egl_window *) win;
 453
 454    surface->pending_resource = NULL;
 455    surface->block_swap_buffers = FALSE;
 456    surface->type = WL_WINDOW_SURFACE;
 457
 458    surface->buffer[WL_BUFFER_FRONT] = NULL;
 459    surface->buffer[WL_BUFFER_BACK] = NULL;
 460    surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
 461       (1 << NATIVE_ATTACHMENT_BACK_LEFT);
 462
 463    surface->rsurf = resource_surface_create(display->base.screen,
 464                                             surface->color_format, bind);
 465
 466    if (!surface->rsurf) {
 467       FREE(surface);
 468       return NULL;
 469    }
 470
 471    surface->base.destroy = wayland_surface_destroy;
 472    surface->base.present = wayland_surface_present;
 473    surface->base.validate = wayland_surface_validate;
 474    surface->base.wait = wayland_surface_wait;
 475
 476    return &surface->base;
 477 }
 478
 479 static struct native_display *
 480 native_create_display(void *dpy, boolean use_sw)
 481 {
 482    struct wayland_display *display = NULL;
 483    boolean own_dpy = FALSE;
 484
 485    use_sw = use_sw || debug_get_bool_option("EGL_SOFTWARE", FALSE);
 486
 487    if (dpy == NULL) {
 488       dpy = wl_display_connect(NULL);
 489       if (dpy == NULL)
 490          return NULL;
 491       own_dpy = TRUE;
 492    }
 493
 494    if (use_sw) {
 495       _eglLog(_EGL_INFO, "use software fallback");
 496       display = wayland_create_shm_display((struct wl_display *) dpy,
 497                                            wayland_event_handler);
 498    } else {
 499       display = wayland_create_drm_display((struct wl_display *) dpy,
 500                                            wayland_event_handler);
 501    }
 502
 503    if (!display)
 504       return NULL;
 505
 506    display->base.get_param = wayland_display_get_param;
 507    display->base.get_configs = wayland_display_get_configs;
 508    display->base.get_pixmap_format = wayland_display_get_pixmap_format;
 509    display->base.copy_to_pixmap = native_display_copy_to_pixmap;
 510    display->base.create_window_surface = wayland_create_window_surface;
 511    display->base.create_pixmap_surface = wayland_create_pixmap_surface;
 512
 513    display->own_dpy = own_dpy;
 514
 515    return &display->base;
 516 }
 517
 518 static const struct native_platform wayland_platform = {
 519    "wayland", /* name */
 520    native_create_display
 521 };
 522
 523 const struct native_platform *
 524 native_get_wayland_platform(const struct native_event_handler *event_handler)
 525 {
 526    wayland_event_handler = event_handler;
 527    return &wayland_platform;
 528 }
 529
 530 /* vim: set sw=3 ts=8 sts=3 expandtab: */