#include <hardware/gralloc.h>
#include <hardware/hardware.h>
#include <hardware/hwvulkan.h>
-#include <vndk/hardware_buffer.h>
#include <vulkan/vk_android_native_buffer.h>
#include <vulkan/vk_icd.h>
#include <libsync.h>
+
+#if ANDROID_API_LEVEL >= 26
+#include <hardware/gralloc1.h>
+#include <vndk/hardware_buffer.h>
#endif
+#endif
+
+#include "util/os_file.h"
#include "radv_private.h"
#include "vk_util.h"
RADV_FROM_HANDLE(radv_device, device, device_h);
VkImage image_h = VK_NULL_HANDLE;
struct radv_image *image = NULL;
- struct radv_bo *bo = NULL;
VkResult result;
if (gralloc_info->handle->numFds != 1) {
const VkImportMemoryFdInfoKHR import_info = {
.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
- .fd = dup(dma_buf),
+ .fd = os_dupfd_cloexec(dma_buf),
};
/* Find the first VRAM memory type, or GART for PRIME images. */
return VK_SUCCESS;
}
+VkResult radv_GetSwapchainGrallocUsage2ANDROID(
+ VkDevice device_h,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
+ uint64_t* grallocConsumerUsage,
+ uint64_t* grallocProducerUsage)
+{
+ /* Before level 26 (Android 8.0/Oreo) the loader uses
+ * vkGetSwapchainGrallocUsageANDROID. */
+#if ANDROID_API_LEVEL >= 26
+ RADV_FROM_HANDLE(radv_device, device, device_h);
+ struct radv_physical_device *phys_dev = device->physical_device;
+ VkPhysicalDevice phys_dev_h = radv_physical_device_to_handle(phys_dev);
+ VkResult result;
+
+ *grallocConsumerUsage = 0;
+ *grallocProducerUsage = 0;
+
+ if (swapchainImageUsage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID)
+ return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
+ "The Vulkan loader tried to query shared presentable image support");
+
+ const VkPhysicalDeviceImageFormatInfo2 image_format_info = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+ .format = format,
+ .type = VK_IMAGE_TYPE_2D,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+ .usage = imageUsage,
+ };
+
+ VkImageFormatProperties2 image_format_props = {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+ };
+
+ /* Check that requested format and usage are supported. */
+ result = radv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h,
+ &image_format_info, &image_format_props);
+ if (result != VK_SUCCESS) {
+ return vk_errorf(device->instance, result,
+ "radv_GetPhysicalDeviceImageFormatProperties2 failed "
+ "inside %s", __func__);
+ }
+
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
+ *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;
+ *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET;
+ }
+
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) {
+ *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE;
+ }
+
+ if (imageUsage != 0) {
+ return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
+ "unsupported VkImageUsageFlags(0x%x) for gralloc "
+ "swapchain", imageUsage);
+ }
+
+ /*
+ * FINISHME: Advertise all display-supported formats. Mostly
+ * DRM_FORMAT_ARGB2101010 and DRM_FORMAT_ABGR2101010, but need to check
+ * what we need for 30-bit colors.
+ */
+ if (format == VK_FORMAT_B8G8R8A8_UNORM ||
+ format == VK_FORMAT_B5G6R5_UNORM_PACK16) {
+ *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;
+ *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_HWCOMPOSER;
+ }
+
+ if (!*grallocProducerUsage && !*grallocConsumerUsage)
+ return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+ return VK_SUCCESS;
+#else
+ *grallocConsumerUsage = 0;
+ *grallocProducerUsage = 0;
+ return VK_ERROR_FORMAT_NOT_SUPPORTED;
+#endif
+}
+
VkResult
radv_AcquireImageANDROID(
VkDevice device,
VkResult semaphore_result = VK_SUCCESS, fence_result = VK_SUCCESS;
if (semaphore != VK_NULL_HANDLE) {
- int semaphore_fd = nativeFenceFd >= 0 ? dup(nativeFenceFd) : nativeFenceFd;
+ int semaphore_fd = nativeFenceFd >= 0 ? os_dupfd_cloexec(nativeFenceFd) : nativeFenceFd;
semaphore_result = radv_ImportSemaphoreFdKHR(device,
&(VkImportSemaphoreFdInfoKHR) {
.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
.flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
.fd = semaphore_fd,
.semaphore = semaphore,
+ .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
});
}
if (fence != VK_NULL_HANDLE) {
- int fence_fd = nativeFenceFd >= 0 ? dup(nativeFenceFd) : nativeFenceFd;
+ int fence_fd = nativeFenceFd >= 0 ? os_dupfd_cloexec(nativeFenceFd) : nativeFenceFd;
fence_result = radv_ImportFenceFdKHR(device,
&(VkImportFenceFdInfoKHR) {
.sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
.flags = VK_FENCE_IMPORT_TEMPORARY_BIT,
.fd = fence_fd,
.fence = fence,
+ .handleType = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
});
}
{
switch (android_format) {
case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
- return VK_FORMAT_R8G8B8A8_UNORM;
case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+ return VK_FORMAT_R8G8B8A8_UNORM;
case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
return VK_FORMAT_R8G8B8_UNORM;
case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
if (dma_buf < 0)
return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+ uint64_t alloc_size = 0;
mem->bo = device->ws->buffer_from_fd(device->ws, dma_buf,
- priority);
+ priority, &alloc_size);
if (!mem->bo)
return VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (mem->image) {
+ struct radeon_bo_metadata metadata;
+ device->ws->buffer_get_metadata(mem->bo, &metadata);
+
+ struct radv_image_create_info create_info = {
+ .no_metadata_planes = true,
+ .bo_metadata = &metadata
+ };
+
+ VkResult result = radv_image_create_layout(device, create_info, mem->image);
+ if (result != VK_SUCCESS) {
+ device->ws->buffer_destroy(mem->bo);
+ mem->bo = NULL;
+ return result;
+ }
+
+ if (alloc_size < mem->image->size) {
+ device->ws->buffer_destroy(mem->bo);
+ mem->bo = NULL;
+ return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+ }
+ } else if (mem->buffer) {
+ if (alloc_size < mem->buffer->size) {
+ device->ws->buffer_destroy(mem->bo);
+ mem->bo = NULL;
+ return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+ }
+ }
+
/* "If the vkAllocateMemory command succeeds, the implementation must
* acquire a reference to the imported hardware buffer, which it must
* release when the device memory object is freed. If the command fails,
return VK_ERROR_EXTENSION_NOT_PRESENT;
#endif
}
+
+bool radv_android_gralloc_supports_format(VkFormat format, VkImageUsageFlagBits usage) {
+#if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
+ /* Ideally we check Gralloc for what it supports and then merge that with the radv
+ format support, but there is no easy gralloc query besides just creating an image.
+ That seems a bit on the expensive side, so just hardcode for now. */
+ /* TODO: Add multi-plane formats after confirming everything works between radeonsi
+ and radv. */
+ switch(format) {
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ case VK_FORMAT_R5G6B5_UNORM_PACK16:
+ return true;
+ case VK_FORMAT_R8_UNORM:
+ case VK_FORMAT_R8G8_UNORM:
+ return !(usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+ default:
+ return false;
+ }
+#else
+ (void)format;
+ (void)usage;
+ return false;
+#endif
+}
projects / mesa.git / blobdiff