| /* |
| * Copyright © 2022 Jason Ekstrand |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| |
| #include "vk_common_entrypoints.h" |
| #include "vk_device.h" |
| #include "vk_log.h" |
| #include "vk_queue.h" |
| |
| #include "util/libsync.h" |
| |
| #include <unistd.h> |
| |
| VKAPI_ATTR VkResult VKAPI_CALL |
| vk_common_AcquireImageANDROID(VkDevice _device, |
| VkImage image, |
| int nativeFenceFd, |
| VkSemaphore semaphore, |
| VkFence fence) |
| { |
| VK_FROM_HANDLE(vk_device, device, _device); |
| VkResult result = VK_SUCCESS; |
| |
| /* From https://source.android.com/devices/graphics/implement-vulkan : |
| * |
| * "The driver takes ownership of the fence file descriptor and closes |
| * the fence file descriptor when no longer needed. The driver must do |
| * so even if neither a semaphore or fence object is provided, or even |
| * if vkAcquireImageANDROID fails and returns an error." |
| * |
| * The Vulkan spec for VkImportFence/SemaphoreFdKHR(), however, requires |
| * the file descriptor to be left alone on failure. |
| */ |
| int semaphore_fd = -1, fence_fd = -1; |
| if (nativeFenceFd >= 0) { |
| if (semaphore != VK_NULL_HANDLE && fence != VK_NULL_HANDLE) { |
| /* We have both so we have to import the sync file twice. One of |
| * them needs to be a dup. |
| */ |
| semaphore_fd = nativeFenceFd; |
| fence_fd = dup(nativeFenceFd); |
| if (fence_fd < 0) { |
| VkResult err = (errno == EMFILE) ? VK_ERROR_TOO_MANY_OBJECTS : |
| VK_ERROR_OUT_OF_HOST_MEMORY; |
| close(nativeFenceFd); |
| return vk_error(device, err); |
| } |
| } else if (semaphore != VK_NULL_HANDLE) { |
| semaphore_fd = nativeFenceFd; |
| } else if (fence != VK_NULL_HANDLE) { |
| fence_fd = nativeFenceFd; |
| } else { |
| /* Nothing to import into so we have to close the file */ |
| close(nativeFenceFd); |
| } |
| } |
| |
| if (semaphore != VK_NULL_HANDLE) { |
| const VkImportSemaphoreFdInfoKHR info = { |
| .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, |
| .semaphore = semaphore, |
| .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, |
| .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, |
| .fd = semaphore_fd, |
| }; |
| result = device->dispatch_table.ImportSemaphoreFdKHR(_device, &info); |
| if (result == VK_SUCCESS) |
| semaphore_fd = -1; /* The driver took ownership */ |
| } |
| |
| if (result == VK_SUCCESS && fence != VK_NULL_HANDLE) { |
| const VkImportFenceFdInfoKHR info = { |
| .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, |
| .fence = fence, |
| .flags = VK_FENCE_IMPORT_TEMPORARY_BIT, |
| .handleType = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, |
| .fd = fence_fd, |
| }; |
| result = device->dispatch_table.ImportFenceFdKHR(_device, &info); |
| if (result == VK_SUCCESS) |
| fence_fd = -1; /* The driver took ownership */ |
| } |
| |
| if (semaphore_fd >= 0) |
| close(semaphore_fd); |
| if (fence_fd >= 0) |
| close(fence_fd); |
| |
| return result; |
| } |
| |
| |
| VKAPI_ATTR VkResult VKAPI_CALL |
| vk_common_QueueSignalReleaseImageANDROID(VkQueue _queue, |
| uint32_t waitSemaphoreCount, |
| const VkSemaphore *pWaitSemaphores, |
| VkImage image, |
| int *pNativeFenceFd) |
| { |
| VK_FROM_HANDLE(vk_queue, queue, _queue); |
| struct vk_device *device = queue->base.device; |
| VkResult result = VK_SUCCESS; |
| |
| if (waitSemaphoreCount == 0) { |
| if (pNativeFenceFd) |
| *pNativeFenceFd = -1; |
| return VK_SUCCESS; |
| } |
| |
| int fd = -1; |
| |
| for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { |
| const VkSemaphoreGetFdInfoKHR get_fd = { |
| .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, |
| .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, |
| .semaphore = pWaitSemaphores[i], |
| }; |
| int tmp_fd; |
| result = device->dispatch_table.GetSemaphoreFdKHR(vk_device_to_handle(device), |
| &get_fd, &tmp_fd); |
| if (result != VK_SUCCESS) { |
| if (fd >= 0) |
| close(fd); |
| return result; |
| } |
| |
| if (fd < 0) { |
| fd = tmp_fd; |
| } else if (tmp_fd >= 0) { |
| sync_accumulate("vulkan", &fd, tmp_fd); |
| close(tmp_fd); |
| } |
| } |
| |
| if (pNativeFenceFd) { |
| *pNativeFenceFd = fd; |
| } else if (fd >= 0) { |
| close(fd); |
| /* We still need to do the exports, to reset the semaphores, but |
| * otherwise we don't wait on them. */ |
| } |
| return VK_SUCCESS; |
| } |