X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_formats.c;h=104d4f7a5fe74ae0e9463f604595f7df282c5c48;hb=621b3410f5f88e2a3743bc025b100717cac26e63;hp=f6915540fb3d0760ec503d8173395e04ecee83a2;hpb=2fef0d108aa52e5e7e7c2b394d18131952a829a6;p=mesa.git diff --git a/src/intel/vulkan/anv_formats.c b/src/intel/vulkan/anv_formats.c index f6915540fb3..104d4f7a5fe 100644 --- a/src/intel/vulkan/anv_formats.c +++ b/src/intel/vulkan/anv_formats.c @@ -23,6 +23,7 @@ #include "anv_private.h" #include "vk_format_info.h" +#include "vk_util.h" /* * gcc-4 and earlier don't allow compound literals where a constant @@ -87,7 +88,7 @@ static const struct anv_format anv_formats[] = { fmt(VK_FORMAT_R8G8B8_SSCALED, ISL_FORMAT_R8G8B8_SSCALED), fmt(VK_FORMAT_R8G8B8_UINT, ISL_FORMAT_R8G8B8_UINT), fmt(VK_FORMAT_R8G8B8_SINT, ISL_FORMAT_R8G8B8_SINT), - fmt(VK_FORMAT_R8G8B8_SRGB, ISL_FORMAT_UNSUPPORTED), /* B8G8R8A8_UNORM_SRGB */ + fmt(VK_FORMAT_R8G8B8_SRGB, ISL_FORMAT_R8G8B8_UNORM_SRGB), fmt(VK_FORMAT_R8G8B8A8_UNORM, ISL_FORMAT_R8G8B8A8_UNORM), fmt(VK_FORMAT_R8G8B8A8_SNORM, ISL_FORMAT_R8G8B8A8_SNORM), fmt(VK_FORMAT_R8G8B8A8_USCALED, ISL_FORMAT_R8G8B8A8_USCALED), @@ -156,16 +157,16 @@ static const struct anv_format anv_formats[] = { fmt(VK_FORMAT_R32G32B32A32_SFLOAT, ISL_FORMAT_R32G32B32A32_FLOAT), fmt(VK_FORMAT_R64_UINT, ISL_FORMAT_R64_PASSTHRU), fmt(VK_FORMAT_R64_SINT, ISL_FORMAT_R64_PASSTHRU), - fmt(VK_FORMAT_R64_SFLOAT, ISL_FORMAT_R64_FLOAT), + fmt(VK_FORMAT_R64_SFLOAT, ISL_FORMAT_R64_PASSTHRU), fmt(VK_FORMAT_R64G64_UINT, ISL_FORMAT_R64G64_PASSTHRU), fmt(VK_FORMAT_R64G64_SINT, ISL_FORMAT_R64G64_PASSTHRU), - fmt(VK_FORMAT_R64G64_SFLOAT, ISL_FORMAT_R64G64_FLOAT), + fmt(VK_FORMAT_R64G64_SFLOAT, ISL_FORMAT_R64G64_PASSTHRU), fmt(VK_FORMAT_R64G64B64_UINT, ISL_FORMAT_R64G64B64_PASSTHRU), fmt(VK_FORMAT_R64G64B64_SINT, ISL_FORMAT_R64G64B64_PASSTHRU), - fmt(VK_FORMAT_R64G64B64_SFLOAT, ISL_FORMAT_R64G64B64_FLOAT), + fmt(VK_FORMAT_R64G64B64_SFLOAT, ISL_FORMAT_R64G64B64_PASSTHRU), fmt(VK_FORMAT_R64G64B64A64_UINT, ISL_FORMAT_R64G64B64A64_PASSTHRU), fmt(VK_FORMAT_R64G64B64A64_SINT, ISL_FORMAT_R64G64B64A64_PASSTHRU), - fmt(VK_FORMAT_R64G64B64A64_SFLOAT, ISL_FORMAT_R64G64B64A64_FLOAT), + fmt(VK_FORMAT_R64G64B64A64_SFLOAT, ISL_FORMAT_R64G64B64A64_PASSTHRU), fmt(VK_FORMAT_B10G11R11_UFLOAT_PACK32, ISL_FORMAT_R11G11B10_FLOAT), fmt(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, ISL_FORMAT_R9G9B9E5_SHAREDEXP), @@ -177,8 +178,8 @@ static const struct anv_format anv_formats[] = { fmt(VK_FORMAT_D24_UNORM_S8_UINT, ISL_FORMAT_R24_UNORM_X8_TYPELESS), fmt(VK_FORMAT_D32_SFLOAT_S8_UINT, ISL_FORMAT_R32_FLOAT), - fmt(VK_FORMAT_BC1_RGB_UNORM_BLOCK, ISL_FORMAT_DXT1_RGB), - fmt(VK_FORMAT_BC1_RGB_SRGB_BLOCK, ISL_FORMAT_DXT1_RGB_SRGB), + swiz_fmt(VK_FORMAT_BC1_RGB_UNORM_BLOCK, ISL_FORMAT_BC1_UNORM, RGB1), + swiz_fmt(VK_FORMAT_BC1_RGB_SRGB_BLOCK, ISL_FORMAT_BC1_UNORM_SRGB, RGB1), fmt(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, ISL_FORMAT_BC1_UNORM), fmt(VK_FORMAT_BC1_RGBA_SRGB_BLOCK, ISL_FORMAT_BC1_UNORM_SRGB), fmt(VK_FORMAT_BC2_UNORM_BLOCK, ISL_FORMAT_BC2_UNORM), @@ -295,10 +296,10 @@ anv_get_format(const struct gen_device_info *devinfo, VkFormat vk_format, } } - /* The B4G4R4A4 format isn't available prior to Sky Lake so we have to fall + /* The B4G4R4A4 format isn't available prior to Broadwell so we have to fall * back to a format with a more complex swizzle. */ - if (vk_format == VK_FORMAT_B4G4R4A4_UNORM_PACK16 && devinfo->gen < 9) { + if (vk_format == VK_FORMAT_B4G4R4A4_UNORM_PACK16 && devinfo->gen < 8) { return (struct anv_format) { .isl_format = ISL_FORMAT_B4G4R4A4_UNORM, .swizzle = ISL_SWIZZLE(GREEN, RED, ALPHA, BLUE), @@ -348,6 +349,11 @@ get_image_format_properties(const struct gen_device_info *devinfo, if (base == ISL_FORMAT_R32_SINT || base == ISL_FORMAT_R32_UINT) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; + if (flags) { + flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; + } + return flags; } @@ -372,6 +378,11 @@ get_buffer_format_properties(const struct gen_device_info *devinfo, if (format == ISL_FORMAT_R32_SINT || format == ISL_FORMAT_R32_UINT) flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT; + if (flags) { + flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; + } + return flags; } @@ -393,7 +404,9 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | - VK_FORMAT_FEATURE_BLIT_DST_BIT; + VK_FORMAT_FEATURE_BLIT_DST_BIT | + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; } else { struct anv_format linear_fmt, tiled_fmt; linear_fmt = anv_get_format(&physical_device->info, format, @@ -423,6 +436,10 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d tiled &= ~VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & ~VK_FORMAT_FEATURE_BLIT_DST_BIT; } + + /* ASTC textures must be in Y-tiled memory */ + if (isl_format_get_layout(linear_fmt.isl_format)->txc == ISL_TXC_ASTC) + linear = 0; } out_properties->linearTilingFeatures = linear; @@ -446,16 +463,29 @@ void anv_GetPhysicalDeviceFormatProperties( pFormatProperties); } -VkResult anv_GetPhysicalDeviceImageFormatProperties( +void anv_GetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags createFlags, - VkImageFormatProperties* pImageFormatProperties) + VkFormatProperties2KHR* pFormatProperties) +{ + anv_GetPhysicalDeviceFormatProperties(physicalDevice, format, + &pFormatProperties->formatProperties); + + vk_foreach_struct(ext, pFormatProperties->pNext) { + switch (ext->sType) { + default: + anv_debug_ignored_stype(ext->sType); + break; + } + } +} + +static VkResult +anv_get_image_format_properties( + struct anv_physical_device *physical_device, + const VkPhysicalDeviceImageFormatInfo2KHR *info, + VkImageFormatProperties *pImageFormatProperties) { - ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); VkFormatProperties format_props; VkFormatFeatureFlags format_feature_flags; VkExtent3D maxExtent; @@ -463,21 +493,24 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( uint32_t maxArraySize; VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT; - anv_physical_device_get_format_properties(physical_device, format, + if (anv_formats[info->format].isl_format == ISL_FORMAT_UNSUPPORTED) + goto unsupported; + + anv_physical_device_get_format_properties(physical_device, info->format, &format_props); /* Extract the VkFormatFeatureFlags that are relevant for the queried * tiling. */ - if (tiling == VK_IMAGE_TILING_LINEAR) { + if (info->tiling == VK_IMAGE_TILING_LINEAR) { format_feature_flags = format_props.linearTilingFeatures; - } else if (tiling == VK_IMAGE_TILING_OPTIMAL) { + } else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) { format_feature_flags = format_props.optimalTilingFeatures; } else { unreachable("bad VkImageTiling"); } - switch (type) { + switch (info->type) { default: unreachable("bad VkImageType"); case VK_IMAGE_TYPE_1D: @@ -507,17 +540,28 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( break; } - if (tiling == VK_IMAGE_TILING_OPTIMAL && - type == VK_IMAGE_TYPE_2D && + /* Our hardware doesn't support 1D compressed textures. + * From the SKL PRM, RENDER_SURFACE_STATE::SurfaceFormat: + * * This field cannot be a compressed (BC*, DXT*, FXT*, ETC*, EAC*) format + * if the Surface Type is SURFTYPE_1D. + * * This field cannot be ASTC format if the Surface Type is SURFTYPE_1D. + */ + if (info->type == VK_IMAGE_TYPE_1D && + isl_format_is_compressed(anv_formats[info->format].isl_format)) { + goto unsupported; + } + + if (info->tiling == VK_IMAGE_TILING_OPTIMAL && + info->type == VK_IMAGE_TYPE_2D && (format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) && - !(createFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && - !(usage & VK_IMAGE_USAGE_STORAGE_BIT)) { + !(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && + !(info->usage & VK_IMAGE_USAGE_STORAGE_BIT)) { sampleCounts = isl_device_get_sample_counts(&physical_device->isl_dev); } - if (usage & (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | - VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { + if (info->usage & (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | + VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { /* Accept transfers on anything we can sample from or renderer to. */ if (!(format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | @@ -526,35 +570,35 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( } } - if (usage & VK_IMAGE_USAGE_SAMPLED_BIT) { + if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) { if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { goto unsupported; } } - if (usage & VK_IMAGE_USAGE_STORAGE_BIT) { + if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) { if (!(format_feature_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) { goto unsupported; } } - if (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { + if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { if (!(format_feature_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { goto unsupported; } } - if (usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { + if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) { goto unsupported; } } - if (usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) { + if (info->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) { /* Nothing to check. */ } - if (usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) { + if (info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) { /* Ignore this flag because it was removed from the * provisional_I_20150910 header. */ @@ -586,6 +630,125 @@ unsupported: return VK_ERROR_FORMAT_NOT_SUPPORTED; } +VkResult anv_GetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags createFlags, + VkImageFormatProperties* pImageFormatProperties) +{ + ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); + + const VkPhysicalDeviceImageFormatInfo2KHR info = { + .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, + .pNext = NULL, + .format = format, + .type = type, + .tiling = tiling, + .usage = usage, + .flags = createFlags, + }; + + return anv_get_image_format_properties(physical_device, &info, + pImageFormatProperties); +} + +static const VkExternalMemoryPropertiesKHX prime_fd_props = { + /* If we can handle external, then we can both import and export it. */ + .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX | + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX, + /* For the moment, let's not support mixing and matching */ + .exportFromImportedHandleTypes = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, + .compatibleHandleTypes = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, +}; + +VkResult anv_GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2KHR* base_info, + VkImageFormatProperties2KHR* base_props) +{ + ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); + const VkPhysicalDeviceExternalImageFormatInfoKHX *external_info = NULL; + VkExternalImageFormatPropertiesKHX *external_props = NULL; + VkResult result; + + result = anv_get_image_format_properties(physical_device, base_info, + &base_props->imageFormatProperties); + if (result != VK_SUCCESS) + goto fail; + + /* Extract input structs */ + vk_foreach_struct_const(s, base_info->pNext) { + switch (s->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX: + external_info = (const void *) s; + break; + default: + anv_debug_ignored_stype(s->sType); + break; + } + } + + /* Extract output structs */ + vk_foreach_struct(s, base_props->pNext) { + switch (s->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX: + external_props = (void *) s; + break; + default: + anv_debug_ignored_stype(s->sType); + break; + } + } + + /* From the Vulkan 1.0.42 spec: + * + * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2KHR will + * behave as if VkPhysicalDeviceExternalImageFormatInfoKHX was not + * present and VkExternalImageFormatPropertiesKHX will be ignored. + */ + if (external_info && external_info->handleType != 0) { + switch (external_info->handleType) { + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX: + if (external_props) + external_props->externalMemoryProperties = prime_fd_props; + break; + default: + /* From the Vulkan 1.0.42 spec: + * + * If handleType is not compatible with the [parameters] specified + * in VkPhysicalDeviceImageFormatInfo2KHR, then + * vkGetPhysicalDeviceImageFormatProperties2KHR returns + * VK_ERROR_FORMAT_NOT_SUPPORTED. + */ + result = vk_errorf(VK_ERROR_FORMAT_NOT_SUPPORTED, + "unsupported VkExternalMemoryTypeFlagBitsKHX 0x%x", + external_info->handleType); + goto fail; + } + } + + return VK_SUCCESS; + + fail: + if (result == VK_ERROR_FORMAT_NOT_SUPPORTED) { + /* From the Vulkan 1.0.42 spec: + * + * If the combination of parameters to + * vkGetPhysicalDeviceImageFormatProperties2KHR is not supported by + * the implementation for use in vkCreateImage, then all members of + * imageFormatProperties will be filled with zero. + */ + base_props->imageFormatProperties = (VkImageFormatProperties) {0}; + } + + return result; +} + void anv_GetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, @@ -599,3 +762,46 @@ void anv_GetPhysicalDeviceSparseImageFormatProperties( /* Sparse images are not yet supported. */ *pNumProperties = 0; } + +void anv_GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties) +{ + /* Sparse images are not yet supported. */ + *pPropertyCount = 0; +} + +void anv_GetPhysicalDeviceExternalBufferPropertiesKHX( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, + VkExternalBufferPropertiesKHX* pExternalBufferProperties) +{ + /* The Vulkan 1.0.42 spec says "handleType must be a valid + * VkExternalMemoryHandleTypeFlagBitsKHX value" in + * VkPhysicalDeviceExternalBufferInfoKHX. This differs from + * VkPhysicalDeviceExternalImageFormatInfoKHX, which surprisingly permits + * handleType == 0. + */ + assert(pExternalBufferInfo->handleType != 0); + + /* All of the current flags are for sparse which we don't support yet. + * Even when we do support it, doing sparse on external memory sounds + * sketchy. Also, just disallowing flags is the safe option. + */ + if (pExternalBufferInfo->flags) + goto unsupported; + + switch (pExternalBufferInfo->handleType) { + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX: + pExternalBufferProperties->externalMemoryProperties = prime_fd_props; + return; + default: + goto unsupported; + } + + unsupported: + pExternalBufferProperties->externalMemoryProperties = + (VkExternalMemoryPropertiesKHX) {0}; +}