vulkan/wsi/wayland: Use per-display event queue
[mesa.git] / src / vulkan / wsi / wsi_common_wayland.c
1 /*
2 * Copyright © 2015 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <wayland-client.h>
25
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <unistd.h>
30 #include <errno.h>
31 #include <string.h>
32 #include <pthread.h>
33
34 #include "util/vk_util.h"
35 #include "wsi_common_wayland.h"
36 #include "wayland-drm-client-protocol.h"
37
38 #include <util/hash_table.h>
39 #include <util/u_vector.h>
40
41 #define typed_memcpy(dest, src, count) ({ \
42 STATIC_ASSERT(sizeof(*src) == sizeof(*dest)); \
43 memcpy((dest), (src), (count) * sizeof(*(src))); \
44 })
45
46 struct wsi_wayland;
47
48 struct wsi_wl_display {
49 /* The real wl_display */
50 struct wl_display * wl_display;
51 /* Actually a proxy wrapper around the event queue */
52 struct wl_display * wl_display_wrapper;
53 struct wl_event_queue * queue;
54 struct wl_drm * drm;
55
56 struct wsi_wayland *wsi_wl;
57 /* Vector of VkFormats supported */
58 struct u_vector formats;
59
60 uint32_t capabilities;
61 };
62
63 struct wsi_wayland {
64 struct wsi_interface base;
65
66 const VkAllocationCallbacks *alloc;
67 VkPhysicalDevice physical_device;
68
69 pthread_mutex_t mutex;
70 /* Hash table of wl_display -> wsi_wl_display mappings */
71 struct hash_table * displays;
72
73 const struct wsi_callbacks *cbs;
74 };
75
76 static void
77 wsi_wl_display_add_vk_format(struct wsi_wl_display *display, VkFormat format)
78 {
79 /* Don't add a format that's already in the list */
80 VkFormat *f;
81 u_vector_foreach(f, &display->formats)
82 if (*f == format)
83 return;
84
85 /* Don't add formats that aren't renderable. */
86 VkFormatProperties props;
87
88 display->wsi_wl->cbs->get_phys_device_format_properties(display->wsi_wl->physical_device,
89 format, &props);
90 if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
91 return;
92
93 f = u_vector_add(&display->formats);
94 if (f)
95 *f = format;
96 }
97
98 static void
99 drm_handle_device(void *data, struct wl_drm *drm, const char *name)
100 {
101 fprintf(stderr, "wl_drm.device(%s)\n", name);
102 }
103
104 static uint32_t
105 wl_drm_format_for_vk_format(VkFormat vk_format, bool alpha)
106 {
107 switch (vk_format) {
108 /* TODO: Figure out what all the formats mean and make this table
109 * correct.
110 */
111 #if 0
112 case VK_FORMAT_R4G4B4A4_UNORM:
113 return alpha ? WL_DRM_FORMAT_ABGR4444 : WL_DRM_FORMAT_XBGR4444;
114 case VK_FORMAT_R5G6B5_UNORM:
115 return WL_DRM_FORMAT_BGR565;
116 case VK_FORMAT_R5G5B5A1_UNORM:
117 return alpha ? WL_DRM_FORMAT_ABGR1555 : WL_DRM_FORMAT_XBGR1555;
118 case VK_FORMAT_R8G8B8_UNORM:
119 return WL_DRM_FORMAT_XBGR8888;
120 case VK_FORMAT_R8G8B8A8_UNORM:
121 return alpha ? WL_DRM_FORMAT_ABGR8888 : WL_DRM_FORMAT_XBGR8888;
122 case VK_FORMAT_R10G10B10A2_UNORM:
123 return alpha ? WL_DRM_FORMAT_ABGR2101010 : WL_DRM_FORMAT_XBGR2101010;
124 case VK_FORMAT_B4G4R4A4_UNORM:
125 return alpha ? WL_DRM_FORMAT_ARGB4444 : WL_DRM_FORMAT_XRGB4444;
126 case VK_FORMAT_B5G6R5_UNORM:
127 return WL_DRM_FORMAT_RGB565;
128 case VK_FORMAT_B5G5R5A1_UNORM:
129 return alpha ? WL_DRM_FORMAT_XRGB1555 : WL_DRM_FORMAT_XRGB1555;
130 #endif
131 case VK_FORMAT_B8G8R8_UNORM:
132 case VK_FORMAT_B8G8R8_SRGB:
133 return WL_DRM_FORMAT_BGRX8888;
134 case VK_FORMAT_B8G8R8A8_UNORM:
135 case VK_FORMAT_B8G8R8A8_SRGB:
136 return alpha ? WL_DRM_FORMAT_ARGB8888 : WL_DRM_FORMAT_XRGB8888;
137 #if 0
138 case VK_FORMAT_B10G10R10A2_UNORM:
139 return alpha ? WL_DRM_FORMAT_ARGB2101010 : WL_DRM_FORMAT_XRGB2101010;
140 #endif
141
142 default:
143 assert(!"Unsupported Vulkan format");
144 return 0;
145 }
146 }
147
148 static void
149 drm_handle_format(void *data, struct wl_drm *drm, uint32_t wl_format)
150 {
151 struct wsi_wl_display *display = data;
152
153 switch (wl_format) {
154 #if 0
155 case WL_DRM_FORMAT_ABGR4444:
156 case WL_DRM_FORMAT_XBGR4444:
157 wsi_wl_display_add_vk_format(display, VK_FORMAT_R4G4B4A4_UNORM);
158 break;
159 case WL_DRM_FORMAT_BGR565:
160 wsi_wl_display_add_vk_format(display, VK_FORMAT_R5G6B5_UNORM);
161 break;
162 case WL_DRM_FORMAT_ABGR1555:
163 case WL_DRM_FORMAT_XBGR1555:
164 wsi_wl_display_add_vk_format(display, VK_FORMAT_R5G5B5A1_UNORM);
165 break;
166 case WL_DRM_FORMAT_XBGR8888:
167 wsi_wl_display_add_vk_format(display, VK_FORMAT_R8G8B8_UNORM);
168 /* fallthrough */
169 case WL_DRM_FORMAT_ABGR8888:
170 wsi_wl_display_add_vk_format(display, VK_FORMAT_R8G8B8A8_UNORM);
171 break;
172 case WL_DRM_FORMAT_ABGR2101010:
173 case WL_DRM_FORMAT_XBGR2101010:
174 wsi_wl_display_add_vk_format(display, VK_FORMAT_R10G10B10A2_UNORM);
175 break;
176 case WL_DRM_FORMAT_ARGB4444:
177 case WL_DRM_FORMAT_XRGB4444:
178 wsi_wl_display_add_vk_format(display, VK_FORMAT_B4G4R4A4_UNORM);
179 break;
180 case WL_DRM_FORMAT_RGB565:
181 wsi_wl_display_add_vk_format(display, VK_FORMAT_B5G6R5_UNORM);
182 break;
183 case WL_DRM_FORMAT_ARGB1555:
184 case WL_DRM_FORMAT_XRGB1555:
185 wsi_wl_display_add_vk_format(display, VK_FORMAT_B5G5R5A1_UNORM);
186 break;
187 #endif
188 case WL_DRM_FORMAT_XRGB8888:
189 wsi_wl_display_add_vk_format(display, VK_FORMAT_B8G8R8_SRGB);
190 wsi_wl_display_add_vk_format(display, VK_FORMAT_B8G8R8_UNORM);
191 /* fallthrough */
192 case WL_DRM_FORMAT_ARGB8888:
193 wsi_wl_display_add_vk_format(display, VK_FORMAT_B8G8R8A8_SRGB);
194 wsi_wl_display_add_vk_format(display, VK_FORMAT_B8G8R8A8_UNORM);
195 break;
196 #if 0
197 case WL_DRM_FORMAT_ARGB2101010:
198 case WL_DRM_FORMAT_XRGB2101010:
199 wsi_wl_display_add_vk_format(display, VK_FORMAT_B10G10R10A2_UNORM);
200 break;
201 #endif
202 }
203 }
204
205 static void
206 drm_handle_authenticated(void *data, struct wl_drm *drm)
207 {
208 }
209
210 static void
211 drm_handle_capabilities(void *data, struct wl_drm *drm, uint32_t capabilities)
212 {
213 struct wsi_wl_display *display = data;
214
215 display->capabilities = capabilities;
216 }
217
218 static const struct wl_drm_listener drm_listener = {
219 drm_handle_device,
220 drm_handle_format,
221 drm_handle_authenticated,
222 drm_handle_capabilities,
223 };
224
225 static void
226 registry_handle_global(void *data, struct wl_registry *registry,
227 uint32_t name, const char *interface, uint32_t version)
228 {
229 struct wsi_wl_display *display = data;
230
231 if (strcmp(interface, "wl_drm") == 0) {
232 assert(display->drm == NULL);
233
234 assert(version >= 2);
235 display->drm = wl_registry_bind(registry, name, &wl_drm_interface, 2);
236
237 if (display->drm)
238 wl_drm_add_listener(display->drm, &drm_listener, display);
239 }
240 }
241
242 static void
243 registry_handle_global_remove(void *data, struct wl_registry *registry,
244 uint32_t name)
245 { /* No-op */ }
246
247 static const struct wl_registry_listener registry_listener = {
248 registry_handle_global,
249 registry_handle_global_remove
250 };
251
252 static void
253 wsi_wl_display_destroy(struct wsi_wayland *wsi, struct wsi_wl_display *display)
254 {
255 u_vector_finish(&display->formats);
256 if (display->drm)
257 wl_drm_destroy(display->drm);
258 if (display->wl_display_wrapper)
259 wl_proxy_wrapper_destroy(display->wl_display_wrapper);
260 if (display->queue)
261 wl_event_queue_destroy(display->queue);
262 vk_free(wsi->alloc, display);
263 }
264
265 static struct wsi_wl_display *
266 wsi_wl_display_create(struct wsi_wayland *wsi, struct wl_display *wl_display)
267 {
268 struct wsi_wl_display *display =
269 vk_alloc(wsi->alloc, sizeof(*display), 8,
270 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
271 if (!display)
272 return NULL;
273
274 memset(display, 0, sizeof(*display));
275
276 display->wsi_wl = wsi;
277 display->wl_display = wl_display;
278
279 if (!u_vector_init(&display->formats, sizeof(VkFormat), 8))
280 goto fail;
281
282 display->queue = wl_display_create_queue(wl_display);
283 if (!display->queue)
284 goto fail;
285
286 display->wl_display_wrapper = wl_proxy_create_wrapper(wl_display);
287 if (!display->wl_display_wrapper)
288 goto fail;
289
290 wl_proxy_set_queue((struct wl_proxy *) display->wl_display_wrapper,
291 display->queue);
292
293 struct wl_registry *registry =
294 wl_display_get_registry(display->wl_display_wrapper);
295 if (!registry)
296 goto fail;
297
298 wl_registry_add_listener(registry, &registry_listener, display);
299
300 /* Round-trip to get the wl_drm global */
301 wl_display_roundtrip_queue(display->wl_display, display->queue);
302
303 if (!display->drm)
304 goto fail_registry;
305
306 /* Round-trip to get wl_drm formats and capabilities */
307 wl_display_roundtrip_queue(display->wl_display, display->queue);
308
309 /* We need prime support */
310 if (!(display->capabilities & WL_DRM_CAPABILITY_PRIME))
311 goto fail_registry;
312
313 /* We don't need this anymore */
314 wl_registry_destroy(registry);
315
316 return display;
317
318 fail_registry:
319 if (registry)
320 wl_registry_destroy(registry);
321
322 fail:
323 wsi_wl_display_destroy(wsi, display);
324 return NULL;
325 }
326
327 static struct wsi_wl_display *
328 wsi_wl_get_display(struct wsi_device *wsi_device,
329 struct wl_display *wl_display)
330 {
331 struct wsi_wayland *wsi =
332 (struct wsi_wayland *)wsi_device->wsi[VK_ICD_WSI_PLATFORM_WAYLAND];
333
334 pthread_mutex_lock(&wsi->mutex);
335
336 struct hash_entry *entry = _mesa_hash_table_search(wsi->displays,
337 wl_display);
338 if (!entry) {
339 /* We're about to make a bunch of blocking calls. Let's drop the
340 * mutex for now so we don't block up too badly.
341 */
342 pthread_mutex_unlock(&wsi->mutex);
343
344 struct wsi_wl_display *display = wsi_wl_display_create(wsi, wl_display);
345 if (!display)
346 return NULL;
347
348 pthread_mutex_lock(&wsi->mutex);
349
350 entry = _mesa_hash_table_search(wsi->displays, wl_display);
351 if (entry) {
352 /* Oops, someone raced us to it */
353 wsi_wl_display_destroy(wsi, display);
354 } else {
355 entry = _mesa_hash_table_insert(wsi->displays, wl_display, display);
356 }
357 }
358
359 pthread_mutex_unlock(&wsi->mutex);
360
361 return entry->data;
362 }
363
364 VkBool32
365 wsi_wl_get_presentation_support(struct wsi_device *wsi_device,
366 struct wl_display *wl_display)
367 {
368 return wsi_wl_get_display(wsi_device, wl_display) != NULL;
369 }
370
371 static VkResult
372 wsi_wl_surface_get_support(VkIcdSurfaceBase *surface,
373 struct wsi_device *wsi_device,
374 const VkAllocationCallbacks *alloc,
375 uint32_t queueFamilyIndex,
376 int local_fd,
377 bool can_handle_different_gpu,
378 VkBool32* pSupported)
379 {
380 *pSupported = true;
381
382 return VK_SUCCESS;
383 }
384
385 static const VkPresentModeKHR present_modes[] = {
386 VK_PRESENT_MODE_MAILBOX_KHR,
387 VK_PRESENT_MODE_FIFO_KHR,
388 };
389
390 static VkResult
391 wsi_wl_surface_get_capabilities(VkIcdSurfaceBase *surface,
392 VkSurfaceCapabilitiesKHR* caps)
393 {
394 /* For true mailbox mode, we need at least 4 images:
395 * 1) One to scan out from
396 * 2) One to have queued for scan-out
397 * 3) One to be currently held by the Wayland compositor
398 * 4) One to render to
399 */
400 caps->minImageCount = 4;
401 /* There is no real maximum */
402 caps->maxImageCount = 0;
403
404 caps->currentExtent = (VkExtent2D) { -1, -1 };
405 caps->minImageExtent = (VkExtent2D) { 1, 1 };
406 /* This is the maximum supported size on Intel */
407 caps->maxImageExtent = (VkExtent2D) { 1 << 14, 1 << 14 };
408 caps->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
409 caps->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
410 caps->maxImageArrayLayers = 1;
411
412 caps->supportedCompositeAlpha =
413 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
414 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
415
416 caps->supportedUsageFlags =
417 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
418 VK_IMAGE_USAGE_SAMPLED_BIT |
419 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
420 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
421
422 return VK_SUCCESS;
423 }
424
425 static VkResult
426 wsi_wl_surface_get_capabilities2(VkIcdSurfaceBase *surface,
427 const void *info_next,
428 VkSurfaceCapabilities2KHR* caps)
429 {
430 assert(caps->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR);
431
432 return wsi_wl_surface_get_capabilities(surface, &caps->surfaceCapabilities);
433 }
434
435 static VkResult
436 wsi_wl_surface_get_formats(VkIcdSurfaceBase *icd_surface,
437 struct wsi_device *wsi_device,
438 uint32_t* pSurfaceFormatCount,
439 VkSurfaceFormatKHR* pSurfaceFormats)
440 {
441 VkIcdSurfaceWayland *surface = (VkIcdSurfaceWayland *)icd_surface;
442 struct wsi_wl_display *display =
443 wsi_wl_get_display(wsi_device, surface->display);
444 if (!display)
445 return VK_ERROR_OUT_OF_HOST_MEMORY;
446
447 VK_OUTARRAY_MAKE(out, pSurfaceFormats, pSurfaceFormatCount);
448
449 VkFormat *disp_fmt;
450 u_vector_foreach(disp_fmt, &display->formats) {
451 vk_outarray_append(&out, out_fmt) {
452 out_fmt->format = *disp_fmt;
453 out_fmt->colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
454 }
455 }
456
457 return vk_outarray_status(&out);
458 }
459
460 static VkResult
461 wsi_wl_surface_get_formats2(VkIcdSurfaceBase *icd_surface,
462 struct wsi_device *wsi_device,
463 const void *info_next,
464 uint32_t* pSurfaceFormatCount,
465 VkSurfaceFormat2KHR* pSurfaceFormats)
466 {
467 VkIcdSurfaceWayland *surface = (VkIcdSurfaceWayland *)icd_surface;
468 struct wsi_wl_display *display =
469 wsi_wl_get_display(wsi_device, surface->display);
470 if (!display)
471 return VK_ERROR_OUT_OF_HOST_MEMORY;
472
473 VK_OUTARRAY_MAKE(out, pSurfaceFormats, pSurfaceFormatCount);
474
475 VkFormat *disp_fmt;
476 u_vector_foreach(disp_fmt, &display->formats) {
477 vk_outarray_append(&out, out_fmt) {
478 out_fmt->surfaceFormat.format = *disp_fmt;
479 out_fmt->surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
480 }
481 }
482
483 return vk_outarray_status(&out);
484 }
485
486 static VkResult
487 wsi_wl_surface_get_present_modes(VkIcdSurfaceBase *surface,
488 uint32_t* pPresentModeCount,
489 VkPresentModeKHR* pPresentModes)
490 {
491 if (pPresentModes == NULL) {
492 *pPresentModeCount = ARRAY_SIZE(present_modes);
493 return VK_SUCCESS;
494 }
495
496 *pPresentModeCount = MIN2(*pPresentModeCount, ARRAY_SIZE(present_modes));
497 typed_memcpy(pPresentModes, present_modes, *pPresentModeCount);
498
499 if (*pPresentModeCount < ARRAY_SIZE(present_modes))
500 return VK_INCOMPLETE;
501 else
502 return VK_SUCCESS;
503 }
504
505 VkResult wsi_create_wl_surface(const VkAllocationCallbacks *pAllocator,
506 const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
507 VkSurfaceKHR *pSurface)
508 {
509 VkIcdSurfaceWayland *surface;
510
511 surface = vk_alloc(pAllocator, sizeof *surface, 8,
512 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
513 if (surface == NULL)
514 return VK_ERROR_OUT_OF_HOST_MEMORY;
515
516 surface->base.platform = VK_ICD_WSI_PLATFORM_WAYLAND;
517 surface->display = pCreateInfo->display;
518 surface->surface = pCreateInfo->surface;
519
520 *pSurface = VkIcdSurfaceBase_to_handle(&surface->base);
521
522 return VK_SUCCESS;
523 }
524
525 struct wsi_wl_image {
526 VkImage image;
527 VkDeviceMemory memory;
528 struct wl_buffer * buffer;
529 bool busy;
530 };
531
532 struct wsi_wl_swapchain {
533 struct wsi_swapchain base;
534
535 struct wsi_wl_display * display;
536 struct wl_event_queue * queue;
537 struct wl_surface * surface;
538 uint32_t surface_version;
539
540 VkExtent2D extent;
541 VkFormat vk_format;
542 uint32_t drm_format;
543
544 VkPresentModeKHR present_mode;
545 bool fifo_ready;
546
547 struct wsi_wl_image images[0];
548 };
549
550 static VkResult
551 wsi_wl_swapchain_get_images(struct wsi_swapchain *wsi_chain,
552 uint32_t *pCount, VkImage *pSwapchainImages)
553 {
554 struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)wsi_chain;
555 uint32_t ret_count;
556 VkResult result;
557
558 if (pSwapchainImages == NULL) {
559 *pCount = chain->base.image_count;
560 return VK_SUCCESS;
561 }
562
563 result = VK_SUCCESS;
564 ret_count = chain->base.image_count;
565 if (chain->base.image_count > *pCount) {
566 ret_count = *pCount;
567 result = VK_INCOMPLETE;
568 }
569
570 for (uint32_t i = 0; i < ret_count; i++)
571 pSwapchainImages[i] = chain->images[i].image;
572
573 return result;
574 }
575
576 static VkResult
577 wsi_wl_swapchain_acquire_next_image(struct wsi_swapchain *wsi_chain,
578 uint64_t timeout,
579 VkSemaphore semaphore,
580 uint32_t *image_index)
581 {
582 struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)wsi_chain;
583
584 int ret = wl_display_dispatch_queue_pending(chain->display->wl_display,
585 chain->queue);
586 /* XXX: I'm not sure if out-of-date is the right error here. If
587 * wl_display_dispatch_queue_pending fails it most likely means we got
588 * kicked by the server so this seems more-or-less correct.
589 */
590 if (ret < 0)
591 return VK_ERROR_OUT_OF_DATE_KHR;
592
593 while (1) {
594 for (uint32_t i = 0; i < chain->base.image_count; i++) {
595 if (!chain->images[i].busy) {
596 /* We found a non-busy image */
597 *image_index = i;
598 chain->images[i].busy = true;
599 return VK_SUCCESS;
600 }
601 }
602
603 /* This time we do a blocking dispatch because we can't go
604 * anywhere until we get an event.
605 */
606 int ret = wl_display_roundtrip_queue(chain->display->wl_display,
607 chain->queue);
608 if (ret < 0)
609 return VK_ERROR_OUT_OF_DATE_KHR;
610 }
611 }
612
613 static void
614 frame_handle_done(void *data, struct wl_callback *callback, uint32_t serial)
615 {
616 struct wsi_wl_swapchain *chain = data;
617
618 chain->fifo_ready = true;
619
620 wl_callback_destroy(callback);
621 }
622
623 static const struct wl_callback_listener frame_listener = {
624 frame_handle_done,
625 };
626
627 static VkResult
628 wsi_wl_swapchain_queue_present(struct wsi_swapchain *wsi_chain,
629 uint32_t image_index,
630 const VkPresentRegionKHR *damage)
631 {
632 struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)wsi_chain;
633
634 if (chain->base.present_mode == VK_PRESENT_MODE_FIFO_KHR) {
635 while (!chain->fifo_ready) {
636 int ret = wl_display_dispatch_queue(chain->display->wl_display,
637 chain->queue);
638 if (ret < 0)
639 return VK_ERROR_OUT_OF_DATE_KHR;
640 }
641 }
642
643 assert(image_index < chain->base.image_count);
644 wl_surface_attach(chain->surface, chain->images[image_index].buffer, 0, 0);
645
646 if (chain->surface_version >= 4 && damage &&
647 damage->pRectangles && damage->rectangleCount > 0) {
648 for (unsigned i = 0; i < damage->rectangleCount; i++) {
649 const VkRectLayerKHR *rect = &damage->pRectangles[i];
650 assert(rect->layer == 0);
651 wl_surface_damage_buffer(chain->surface,
652 rect->offset.x, rect->offset.y,
653 rect->extent.width, rect->extent.height);
654 }
655 } else {
656 wl_surface_damage(chain->surface, 0, 0, INT32_MAX, INT32_MAX);
657 }
658
659 if (chain->base.present_mode == VK_PRESENT_MODE_FIFO_KHR) {
660 struct wl_callback *frame = wl_surface_frame(chain->surface);
661 wl_proxy_set_queue((struct wl_proxy *)frame, chain->queue);
662 wl_callback_add_listener(frame, &frame_listener, chain);
663 chain->fifo_ready = false;
664 }
665
666 chain->images[image_index].busy = true;
667 wl_surface_commit(chain->surface);
668 wl_display_flush(chain->display->wl_display);
669
670 return VK_SUCCESS;
671 }
672
673 static void
674 buffer_handle_release(void *data, struct wl_buffer *buffer)
675 {
676 struct wsi_wl_image *image = data;
677
678 assert(image->buffer == buffer);
679
680 image->busy = false;
681 }
682
683 static const struct wl_buffer_listener buffer_listener = {
684 buffer_handle_release,
685 };
686
687 static VkResult
688 wsi_wl_image_init(struct wsi_wl_swapchain *chain,
689 struct wsi_wl_image *image,
690 const VkSwapchainCreateInfoKHR *pCreateInfo,
691 const VkAllocationCallbacks* pAllocator)
692 {
693 VkDevice vk_device = chain->base.device;
694 VkResult result;
695 int fd;
696 uint32_t size;
697 uint32_t row_pitch;
698 uint32_t offset;
699 result = chain->base.image_fns->create_wsi_image(vk_device,
700 pCreateInfo,
701 pAllocator,
702 false,
703 false,
704 &image->image,
705 &image->memory,
706 &size,
707 &offset,
708 &row_pitch,
709 &fd);
710 if (result != VK_SUCCESS)
711 return result;
712
713 image->buffer = wl_drm_create_prime_buffer(chain->display->drm,
714 fd, /* name */
715 chain->extent.width,
716 chain->extent.height,
717 chain->drm_format,
718 offset,
719 row_pitch,
720 0, 0, 0, 0 /* unused */);
721 close(fd);
722
723 if (!image->buffer)
724 goto fail_image;
725
726 wl_proxy_set_queue((struct wl_proxy *)image->buffer, chain->queue);
727 wl_buffer_add_listener(image->buffer, &buffer_listener, image);
728
729 return VK_SUCCESS;
730
731 fail_image:
732 chain->base.image_fns->free_wsi_image(vk_device, pAllocator,
733 image->image, image->memory);
734
735 return result;
736 }
737
738 static VkResult
739 wsi_wl_swapchain_destroy(struct wsi_swapchain *wsi_chain,
740 const VkAllocationCallbacks *pAllocator)
741 {
742 struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)wsi_chain;
743
744 for (uint32_t i = 0; i < chain->base.image_count; i++) {
745 if (chain->images[i].buffer)
746 chain->base.image_fns->free_wsi_image(chain->base.device, pAllocator,
747 chain->images[i].image,
748 chain->images[i].memory);
749 }
750
751 vk_free(pAllocator, chain);
752
753 return VK_SUCCESS;
754 }
755
756 static VkResult
757 wsi_wl_surface_create_swapchain(VkIcdSurfaceBase *icd_surface,
758 VkDevice device,
759 struct wsi_device *wsi_device,
760 int local_fd,
761 const VkSwapchainCreateInfoKHR* pCreateInfo,
762 const VkAllocationCallbacks* pAllocator,
763 const struct wsi_image_fns *image_fns,
764 struct wsi_swapchain **swapchain_out)
765 {
766 VkIcdSurfaceWayland *surface = (VkIcdSurfaceWayland *)icd_surface;
767 struct wsi_wl_swapchain *chain;
768 VkResult result;
769
770 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR);
771
772 int num_images = pCreateInfo->minImageCount;
773
774 size_t size = sizeof(*chain) + num_images * sizeof(chain->images[0]);
775 chain = vk_alloc(pAllocator, size, 8,
776 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
777 if (chain == NULL)
778 return VK_ERROR_OUT_OF_HOST_MEMORY;
779
780 bool alpha = pCreateInfo->compositeAlpha ==
781 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
782
783 chain->base.device = device;
784 chain->base.destroy = wsi_wl_swapchain_destroy;
785 chain->base.get_images = wsi_wl_swapchain_get_images;
786 chain->base.acquire_next_image = wsi_wl_swapchain_acquire_next_image;
787 chain->base.queue_present = wsi_wl_swapchain_queue_present;
788 chain->base.image_fns = image_fns;
789 chain->base.present_mode = pCreateInfo->presentMode;
790 chain->base.image_count = num_images;
791 chain->base.needs_linear_copy = false;
792 chain->surface = surface->surface;
793 chain->surface_version = wl_proxy_get_version((void *)surface->surface);
794 chain->extent = pCreateInfo->imageExtent;
795 chain->vk_format = pCreateInfo->imageFormat;
796 chain->drm_format = wl_drm_format_for_vk_format(chain->vk_format, alpha);
797
798 chain->fifo_ready = true;
799
800 /* Mark a bunch of stuff as NULL. This way we can just call
801 * destroy_swapchain for cleanup.
802 */
803 for (uint32_t i = 0; i < chain->base.image_count; i++)
804 chain->images[i].buffer = NULL;
805 chain->queue = NULL;
806
807 chain->display = wsi_wl_get_display(wsi_device,
808 surface->display);
809 if (!chain->display) {
810 result = VK_ERROR_INITIALIZATION_FAILED;
811 goto fail;
812 }
813
814 chain->queue = wl_display_create_queue(chain->display->wl_display);
815 if (!chain->queue) {
816 result = VK_ERROR_INITIALIZATION_FAILED;
817 goto fail;
818 }
819
820 for (uint32_t i = 0; i < chain->base.image_count; i++) {
821 result = wsi_wl_image_init(chain, &chain->images[i],
822 pCreateInfo, pAllocator);
823 if (result != VK_SUCCESS)
824 goto fail;
825 chain->images[i].busy = false;
826 }
827
828 *swapchain_out = &chain->base;
829
830 return VK_SUCCESS;
831
832 fail:
833 wsi_wl_swapchain_destroy(&chain->base, pAllocator);
834
835 return result;
836 }
837
838 VkResult
839 wsi_wl_init_wsi(struct wsi_device *wsi_device,
840 const VkAllocationCallbacks *alloc,
841 VkPhysicalDevice physical_device,
842 const struct wsi_callbacks *cbs)
843 {
844 struct wsi_wayland *wsi;
845 VkResult result;
846
847 wsi = vk_alloc(alloc, sizeof(*wsi), 8,
848 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
849 if (!wsi) {
850 result = VK_ERROR_OUT_OF_HOST_MEMORY;
851 goto fail;
852 }
853
854 wsi->physical_device = physical_device;
855 wsi->alloc = alloc;
856 wsi->cbs = cbs;
857 int ret = pthread_mutex_init(&wsi->mutex, NULL);
858 if (ret != 0) {
859 if (ret == ENOMEM) {
860 result = VK_ERROR_OUT_OF_HOST_MEMORY;
861 } else {
862 /* FINISHME: Choose a better error. */
863 result = VK_ERROR_OUT_OF_HOST_MEMORY;
864 }
865
866 goto fail_alloc;
867 }
868
869 wsi->displays = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
870 _mesa_key_pointer_equal);
871 if (!wsi->displays) {
872 result = VK_ERROR_OUT_OF_HOST_MEMORY;
873 goto fail_mutex;
874 }
875
876 wsi->base.get_support = wsi_wl_surface_get_support;
877 wsi->base.get_capabilities = wsi_wl_surface_get_capabilities;
878 wsi->base.get_capabilities2 = wsi_wl_surface_get_capabilities2;
879 wsi->base.get_formats = wsi_wl_surface_get_formats;
880 wsi->base.get_formats2 = wsi_wl_surface_get_formats2;
881 wsi->base.get_present_modes = wsi_wl_surface_get_present_modes;
882 wsi->base.create_swapchain = wsi_wl_surface_create_swapchain;
883
884 wsi_device->wsi[VK_ICD_WSI_PLATFORM_WAYLAND] = &wsi->base;
885
886 return VK_SUCCESS;
887
888 fail_mutex:
889 pthread_mutex_destroy(&wsi->mutex);
890
891 fail_alloc:
892 vk_free(alloc, wsi);
893 fail:
894 wsi_device->wsi[VK_ICD_WSI_PLATFORM_WAYLAND] = NULL;
895
896 return result;
897 }
898
899 void
900 wsi_wl_finish_wsi(struct wsi_device *wsi_device,
901 const VkAllocationCallbacks *alloc)
902 {
903 struct wsi_wayland *wsi =
904 (struct wsi_wayland *)wsi_device->wsi[VK_ICD_WSI_PLATFORM_WAYLAND];
905
906 if (wsi) {
907 struct hash_entry *entry;
908 hash_table_foreach(wsi->displays, entry)
909 wsi_wl_display_destroy(wsi, entry->data);
910
911 _mesa_hash_table_destroy(wsi->displays, NULL);
912
913 pthread_mutex_destroy(&wsi->mutex);
914
915 vk_free(alloc, wsi);
916 }
917 }