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
38static void
39sync_callback(void *data, struct wl_callback *callback, uint32_t serial)
40{
41   int *done = data;
42
43   *done = 1;
44   wl_callback_destroy(callback);
45}
46
47static const struct wl_callback_listener sync_listener = {
48   sync_callback
49};
50
51int
52wayland_roundtrip(struct wayland_display *display)
53{
54   struct wl_callback *callback;
55   int done = 0, ret = 0;
56
57   callback = wl_display_sync(display->dpy);
58   wl_callback_add_listener(callback, &sync_listener, &done);
59   wl_proxy_set_queue((struct wl_proxy *) callback, display->queue);
60   while (ret != -1 && !done)
61      ret = wl_display_dispatch_queue(display->dpy, display->queue);
62
63   if (!done)
64      wl_callback_destroy(callback);
65
66   return ret;
67}
68
69static const struct native_event_handler *wayland_event_handler;
70
71const static struct {
72   enum pipe_format format;
73   enum wayland_format_flag flag;
74} wayland_formats[] = {
75   { PIPE_FORMAT_B8G8R8A8_UNORM, HAS_ARGB8888 },
76   { PIPE_FORMAT_B8G8R8X8_UNORM, HAS_XRGB8888 },
77};
78
79static const struct native_config **
80wayland_display_get_configs(struct native_display *ndpy, int *num_configs)
81{
82   struct wayland_display *display = wayland_display(ndpy);
83   const struct native_config **configs;
84   int i;
85
86   if (!display->configs) {
87      struct native_config *nconf;
88
89      display->num_configs = 0;
90      display->configs = CALLOC(Elements(wayland_formats),
91                                sizeof(*display->configs));
92      if (!display->configs)
93         return NULL;
94
95      for (i = 0; i < Elements(wayland_formats); ++i) {
96         if (!(display->formats & wayland_formats[i].flag))
97            continue;
98
99         nconf = &display->configs[display->num_configs].base;
100         nconf->buffer_mask =
101            (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
102            (1 << NATIVE_ATTACHMENT_BACK_LEFT);
103
104         nconf->window_bit = TRUE;
105
106         nconf->color_format = wayland_formats[i].format;
107         display->num_configs++;
108      }
109   }
110
111   configs = MALLOC(display->num_configs * sizeof(*configs));
112   if (configs) {
113      for (i = 0; i < display->num_configs; ++i)
114         configs[i] = &display->configs[i].base;
115      if (num_configs)
116         *num_configs = display->num_configs;
117   }
118
119   return configs;
120}
121
122static int
123wayland_display_get_param(struct native_display *ndpy,
124                          enum native_param_type param)
125{
126   int val;
127
128   switch (param) {
129   case NATIVE_PARAM_PREMULTIPLIED_ALPHA:
130      val = 1;
131      break;
132   case NATIVE_PARAM_USE_NATIVE_BUFFER:
133   case NATIVE_PARAM_PRESERVE_BUFFER:
134   case NATIVE_PARAM_MAX_SWAP_INTERVAL:
135   default:
136      val = 0;
137      break;
138   }
139
140   return val;
141}
142
143static void
144wayland_release_pending_resource(void *data,
145                                 struct wl_callback *callback,
146                                 uint32_t time)
147{
148   struct wayland_surface *surface = data;
149
150   wl_callback_destroy(callback);
151
152   /* FIXME: print internal error */
153   if (!surface->pending_resource)
154      return;
155
156   pipe_resource_reference(&surface->pending_resource, NULL);
157}
158
159static const struct wl_callback_listener release_buffer_listener = {
160   wayland_release_pending_resource
161};
162
163static void
164wayland_window_surface_handle_resize(struct wayland_surface *surface)
165{
166   struct wayland_display *display = surface->display;
167   struct pipe_resource *front_resource;
168   const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT;
169   int i;
170
171   front_resource = resource_surface_get_single_resource(surface->rsurf,
172                                                         front_natt);
173   if (resource_surface_set_size(surface->rsurf,
174                                 surface->win->width, surface->win->height)) {
175
176      if (surface->pending_resource)
177         wayland_roundtrip(display);
178
179      if (front_resource) {
180         struct wl_callback *callback;
181
182         surface->pending_resource = front_resource;
183         front_resource = NULL;
184
185         callback = wl_display_sync(display->dpy);
186         wl_callback_add_listener(callback, &release_buffer_listener, surface);
187         wl_proxy_set_queue((struct wl_proxy *) callback, display->queue);
188      }
189
190      for (i = 0; i < WL_BUFFER_COUNT; ++i) {
191         if (surface->buffer[i])
192            wl_buffer_destroy(surface->buffer[i]);
193         surface->buffer[i] = NULL;
194      }
195
196      surface->dx = surface->win->dx;
197      surface->dy = surface->win->dy;
198   }
199   pipe_resource_reference(&front_resource, NULL);
200}
201
202static boolean
203wayland_surface_validate(struct native_surface *nsurf, uint attachment_mask,
204                         unsigned int *seq_num, struct pipe_resource **textures,
205                         int *width, int *height)
206{
207   struct wayland_surface *surface = wayland_surface(nsurf);
208
209   if (surface->type == WL_WINDOW_SURFACE)
210      wayland_window_surface_handle_resize(surface);
211
212   if (!resource_surface_add_resources(surface->rsurf, attachment_mask |
213                                       surface->attachment_mask))
214      return FALSE;
215
216   if (textures)
217      resource_surface_get_resources(surface->rsurf, textures, attachment_mask);
218
219   if (seq_num)
220      *seq_num = surface->sequence_number;
221
222   resource_surface_get_size(surface->rsurf, (uint *) width, (uint *) height);
223
224   return TRUE;
225}
226
227static void
228wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time)
229{
230   struct wayland_surface *surface = data;
231
232   surface->frame_callback = NULL;
233
234   wl_callback_destroy(callback);
235}
236
237static const struct wl_callback_listener frame_listener = {
238   wayland_frame_callback
239};
240
241static INLINE void
242wayland_buffers_swap(struct wl_buffer **buffer,
243                     enum wayland_buffer_type buf1,
244                     enum wayland_buffer_type buf2)
245{
246   struct wl_buffer *tmp = buffer[buf1];
247   buffer[buf1] = buffer[buf2];
248   buffer[buf2] = tmp;
249}
250
251static boolean
252wayland_surface_swap_buffers(struct native_surface *nsurf)
253{
254   struct wayland_surface *surface = wayland_surface(nsurf);
255   struct wayland_display *display = surface->display;
256   int ret = 0;
257
258   while (surface->frame_callback && ret != -1)
259      ret = wl_display_dispatch_queue(display->dpy, display->queue);
260   if (ret == -1)
261      return EGL_FALSE;
262
263   surface->frame_callback = wl_surface_frame(surface->win->surface);
264   wl_callback_add_listener(surface->frame_callback, &frame_listener, surface);
265   wl_proxy_set_queue((struct wl_proxy *) surface->frame_callback,
266                      display->queue);
267
268   if (surface->type == WL_WINDOW_SURFACE) {
269      resource_surface_swap_buffers(surface->rsurf,
270                                    NATIVE_ATTACHMENT_FRONT_LEFT,
271                                    NATIVE_ATTACHMENT_BACK_LEFT, FALSE);
272
273      wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK);
274
275      if (surface->buffer[WL_BUFFER_FRONT] == NULL)
276         surface->buffer[WL_BUFFER_FRONT] =
277            display->create_buffer(display, surface,
278                                   NATIVE_ATTACHMENT_FRONT_LEFT);
279
280      wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT],
281                        surface->dx, surface->dy);
282
283      resource_surface_get_size(surface->rsurf,
284                                (uint *) &surface->win->attached_width,
285                                (uint *) &surface->win->attached_height);
286      surface->dx = 0;
287      surface->dy = 0;
288   }
289
290   surface->sequence_number++;
291   wayland_event_handler->invalid_surface(&display->base,
292                                          &surface->base,
293                                          surface->sequence_number);
294
295   return TRUE;
296}
297
298static boolean
299wayland_surface_present(struct native_surface *nsurf,
300                        const struct native_present_control *ctrl)
301{
302   struct wayland_surface *surface = wayland_surface(nsurf);
303   uint width, height;
304   boolean ret;
305
306   if (ctrl->preserve || ctrl->swap_interval)
307      return FALSE;
308
309   /* force buffers to be re-created if they will be presented differently */
310   if (surface->premultiplied_alpha != ctrl->premultiplied_alpha) {
311      enum wayland_buffer_type buffer;
312
313      for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
314         if (surface->buffer[buffer]) {
315            wl_buffer_destroy(surface->buffer[buffer]);
316            surface->buffer[buffer] = NULL;
317         }
318      }
319
320      surface->premultiplied_alpha = ctrl->premultiplied_alpha;
321   }
322
323   switch (ctrl->natt) {
324   case NATIVE_ATTACHMENT_FRONT_LEFT:
325      ret = TRUE;
326      break;
327   case NATIVE_ATTACHMENT_BACK_LEFT:
328      ret = wayland_surface_swap_buffers(nsurf);
329      break;
330   default:
331      ret = FALSE;
332      break;
333   }
334
335   if (surface->type == WL_WINDOW_SURFACE) {
336      resource_surface_get_size(surface->rsurf, &width, &height);
337      wl_surface_damage(surface->win->surface, 0, 0, width, height);
338      wl_surface_commit(surface->win->surface);
339   }
340
341   return ret;
342}
343
344static void
345wayland_surface_wait(struct native_surface *nsurf)
346{
347   /* no-op */
348}
349
350static void
351wayland_surface_destroy(struct native_surface *nsurf)
352{
353   struct wayland_surface *surface = wayland_surface(nsurf);
354   enum wayland_buffer_type buffer;
355
356   for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
357      if (surface->buffer[buffer])
358         wl_buffer_destroy(surface->buffer[buffer]);
359   }
360
361   if (surface->frame_callback)
362      wl_callback_destroy(surface->frame_callback);
363
364   resource_surface_destroy(surface->rsurf);
365   FREE(surface);
366}
367
368
369static struct native_surface *
370wayland_create_window_surface(struct native_display *ndpy,
371                              EGLNativeWindowType win,
372                              const struct native_config *nconf)
373{
374   struct wayland_display *display = wayland_display(ndpy);
375   struct wayland_config *config = wayland_config(nconf);
376   struct wayland_surface *surface;
377   uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
378      PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT;
379
380   surface = CALLOC_STRUCT(wayland_surface);
381   if (!surface)
382      return NULL;
383
384   surface->display = display;
385   surface->color_format = config->base.color_format;
386
387   surface->win = (struct wl_egl_window *) win;
388
389   surface->pending_resource = NULL;
390   surface->frame_callback = NULL;
391   surface->type = WL_WINDOW_SURFACE;
392
393   surface->buffer[WL_BUFFER_FRONT] = NULL;
394   surface->buffer[WL_BUFFER_BACK] = NULL;
395   surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
396      (1 << NATIVE_ATTACHMENT_BACK_LEFT);
397
398   surface->rsurf = resource_surface_create(display->base.screen,
399                                            surface->color_format, bind);
400
401   if (!surface->rsurf) {
402      FREE(surface);
403      return NULL;
404   }
405
406   surface->base.destroy = wayland_surface_destroy;
407   surface->base.present = wayland_surface_present;
408   surface->base.validate = wayland_surface_validate;
409   surface->base.wait = wayland_surface_wait;
410
411   return &surface->base;
412}
413
414static struct native_display *
415native_create_display(void *dpy, boolean use_sw)
416{
417   struct wayland_display *display = NULL;
418   boolean own_dpy = FALSE;
419
420   use_sw = use_sw || debug_get_bool_option("EGL_SOFTWARE", FALSE);
421
422   if (dpy == NULL) {
423      dpy = wl_display_connect(NULL);
424      if (dpy == NULL)
425         return NULL;
426      own_dpy = TRUE;
427   }
428
429   if (use_sw) {
430      _eglLog(_EGL_INFO, "use software fallback");
431      display = wayland_create_shm_display((struct wl_display *) dpy,
432                                           wayland_event_handler);
433   } else {
434      display = wayland_create_drm_display((struct wl_display *) dpy,
435                                           wayland_event_handler);
436   }
437
438   if (!display)
439      return NULL;
440
441   display->base.get_param = wayland_display_get_param;
442   display->base.get_configs = wayland_display_get_configs;
443   display->base.create_window_surface = wayland_create_window_surface;
444
445   display->own_dpy = own_dpy;
446
447   return &display->base;
448}
449
450static const struct native_platform wayland_platform = {
451   "wayland", /* name */
452   native_create_display
453};
454
455const struct native_platform *
456native_get_wayland_platform(const struct native_event_handler *event_handler)
457{
458   wayland_event_handler = event_handler;
459   return &wayland_platform;
460}
461
462/* vim: set sw=3 ts=8 sts=3 expandtab: */
463