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