src/gallium/frontends/vallium/val_formats.c

   1 /*
   2  * Copyright © 2019 Red Hat.
   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 "val_private.h"
  25 #include "util/format/u_format.h"
  26 #include "util/u_math.h"
  27 #define COMMON_NAME(x) [VK_FORMAT_##x] = PIPE_FORMAT_##x
  28
  29 #define FLOAT_NAME(x) [VK_FORMAT_##x##_SFLOAT] = PIPE_FORMAT_##x##_FLOAT
  30
  31 static enum pipe_format format_to_vk_table[VK_FORMAT_ASTC_12x12_SRGB_BLOCK + 1] = {
  32
  33    COMMON_NAME(R8_UNORM),
  34    COMMON_NAME(R8G8_UNORM),
  35    COMMON_NAME(R8G8B8_UNORM),
  36    COMMON_NAME(R8G8B8A8_UNORM),
  37
  38    COMMON_NAME(R8_SNORM),
  39    COMMON_NAME(R8G8_SNORM),
  40    COMMON_NAME(R8G8B8_SNORM),
  41    COMMON_NAME(R8G8B8A8_SNORM),
  42
  43    //   COMMON_NAME(R8_SRGB),
  44    COMMON_NAME(R8G8B8_SRGB),
  45    COMMON_NAME(R8G8B8A8_SRGB),
  46
  47    COMMON_NAME(B8G8R8A8_UNORM),
  48    COMMON_NAME(R8G8B8A8_SRGB),
  49    COMMON_NAME(B8G8R8A8_SRGB),
  50
  51    COMMON_NAME(R8_UINT),
  52    COMMON_NAME(R8G8_UINT),
  53    COMMON_NAME(R8G8B8_UINT),
  54    COMMON_NAME(R8G8B8A8_UINT),
  55
  56    COMMON_NAME(R16_UINT),
  57    COMMON_NAME(R16G16_UINT),
  58    COMMON_NAME(R16G16B16_UINT),
  59    COMMON_NAME(R16G16B16A16_UINT),
  60
  61    COMMON_NAME(R32_UINT),
  62    COMMON_NAME(R32G32_UINT),
  63    COMMON_NAME(R32G32B32_UINT),
  64    COMMON_NAME(R32G32B32A32_UINT),
  65
  66    COMMON_NAME(R8_SINT),
  67    COMMON_NAME(R8G8_SINT),
  68    COMMON_NAME(R8G8B8_SINT),
  69    COMMON_NAME(R8G8B8A8_SINT),
  70
  71    COMMON_NAME(R16_SINT),
  72    COMMON_NAME(R16G16_SINT),
  73    COMMON_NAME(R16G16B16_SINT),
  74    COMMON_NAME(R16G16B16A16_SINT),
  75
  76    COMMON_NAME(R32_SINT),
  77    COMMON_NAME(R32G32_SINT),
  78    COMMON_NAME(R32G32B32_SINT),
  79    COMMON_NAME(R32G32B32A32_SINT),
  80
  81    COMMON_NAME(R16_UNORM),
  82    COMMON_NAME(R16G16_UNORM),
  83    COMMON_NAME(R16G16B16A16_UNORM),
  84
  85    COMMON_NAME(R16_SNORM),
  86    COMMON_NAME(R16G16_SNORM),
  87    COMMON_NAME(R16G16B16A16_SNORM),
  88    FLOAT_NAME(R16),
  89    FLOAT_NAME(R16G16),
  90    FLOAT_NAME(R16G16B16),
  91    FLOAT_NAME(R16G16B16A16),
  92
  93    FLOAT_NAME(R32),
  94    FLOAT_NAME(R32G32),
  95    FLOAT_NAME(R32G32B32),
  96    FLOAT_NAME(R32G32B32A32),
  97
  98    COMMON_NAME(S8_UINT),
  99    [VK_FORMAT_UNDEFINED] = PIPE_FORMAT_NONE,
 100    [VK_FORMAT_R5G6B5_UNORM_PACK16] = PIPE_FORMAT_B5G6R5_UNORM,
 101    [VK_FORMAT_A1R5G5B5_UNORM_PACK16] = PIPE_FORMAT_B5G5R5A1_UNORM,
 102    [VK_FORMAT_B4G4R4A4_UNORM_PACK16] = PIPE_FORMAT_A4R4G4B4_UNORM,
 103    [VK_FORMAT_D16_UNORM] = PIPE_FORMAT_Z16_UNORM,
 104
 105    [VK_FORMAT_A8B8G8R8_UNORM_PACK32] = PIPE_FORMAT_R8G8B8A8_UNORM,
 106    [VK_FORMAT_A8B8G8R8_SNORM_PACK32] = PIPE_FORMAT_R8G8B8A8_SNORM,
 107    [VK_FORMAT_A8B8G8R8_UINT_PACK32] = PIPE_FORMAT_R8G8B8A8_UINT,
 108    [VK_FORMAT_A8B8G8R8_SINT_PACK32] = PIPE_FORMAT_R8G8B8A8_SINT,
 109    [VK_FORMAT_A8B8G8R8_SRGB_PACK32] = PIPE_FORMAT_R8G8B8A8_SRGB,
 110
 111    [VK_FORMAT_A2B10G10R10_UNORM_PACK32] = PIPE_FORMAT_R10G10B10A2_UNORM,
 112    [VK_FORMAT_A2B10G10R10_UINT_PACK32] = PIPE_FORMAT_R10G10B10A2_UINT,
 113
 114    [VK_FORMAT_B10G11R11_UFLOAT_PACK32] = PIPE_FORMAT_R11G11B10_FLOAT,
 115    [VK_FORMAT_E5B9G9R9_UFLOAT_PACK32] = PIPE_FORMAT_R9G9B9E5_FLOAT,
 116
 117    [VK_FORMAT_X8_D24_UNORM_PACK32] = PIPE_FORMAT_Z24X8_UNORM,
 118    [VK_FORMAT_D32_SFLOAT] = PIPE_FORMAT_Z32_FLOAT,
 119    [VK_FORMAT_D24_UNORM_S8_UINT] = PIPE_FORMAT_Z24_UNORM_S8_UINT,
 120    [VK_FORMAT_D32_SFLOAT_S8_UINT] = PIPE_FORMAT_Z32_FLOAT_S8X24_UINT,
 121
 122    [VK_FORMAT_BC1_RGB_UNORM_BLOCK] = PIPE_FORMAT_DXT1_RGB,
 123    [VK_FORMAT_BC1_RGBA_UNORM_BLOCK] = PIPE_FORMAT_DXT1_RGBA,
 124    [VK_FORMAT_BC2_UNORM_BLOCK] = PIPE_FORMAT_DXT3_RGBA,
 125    [VK_FORMAT_BC3_UNORM_BLOCK] = PIPE_FORMAT_DXT5_RGBA,
 126    [VK_FORMAT_BC4_UNORM_BLOCK] = PIPE_FORMAT_RGTC1_UNORM,
 127    [VK_FORMAT_BC5_UNORM_BLOCK] = PIPE_FORMAT_RGTC2_UNORM,
 128
 129    [VK_FORMAT_BC1_RGB_SRGB_BLOCK] = PIPE_FORMAT_DXT1_SRGB,
 130    [VK_FORMAT_BC1_RGBA_SRGB_BLOCK] = PIPE_FORMAT_DXT1_SRGBA,
 131    [VK_FORMAT_BC2_SRGB_BLOCK] = PIPE_FORMAT_DXT3_SRGBA,
 132    [VK_FORMAT_BC3_SRGB_BLOCK] = PIPE_FORMAT_DXT5_SRGBA,
 133
 134    [VK_FORMAT_BC4_SNORM_BLOCK] = PIPE_FORMAT_RGTC1_SNORM,
 135    [VK_FORMAT_BC5_SNORM_BLOCK] = PIPE_FORMAT_RGTC2_SNORM,
 136
 137    [VK_FORMAT_BC6H_UFLOAT_BLOCK] = PIPE_FORMAT_BPTC_RGB_UFLOAT,
 138    [VK_FORMAT_BC6H_SFLOAT_BLOCK] = PIPE_FORMAT_BPTC_RGB_FLOAT,
 139    [VK_FORMAT_BC7_UNORM_BLOCK] = PIPE_FORMAT_BPTC_RGBA_UNORM,
 140    [VK_FORMAT_BC7_SRGB_BLOCK] = PIPE_FORMAT_BPTC_SRGBA,
 141 };
 142
 143 enum pipe_format vk_format_to_pipe(VkFormat format)
 144 {
 145    if (format > VK_FORMAT_ASTC_12x12_SRGB_BLOCK)
 146       return PIPE_FORMAT_NONE;
 147    return format_to_vk_table[format];
 148 }
 149
 150 static void
 151 val_physical_device_get_format_properties(struct val_physical_device *physical_device,
 152                                           VkFormat format,
 153                                           VkFormatProperties *out_properties)
 154 {
 155    enum pipe_format pformat = vk_format_to_pipe(format);
 156    unsigned features = 0, buffer_features = 0;
 157    if (pformat == PIPE_FORMAT_NONE) {
 158      out_properties->linearTilingFeatures = 0;
 159      out_properties->optimalTilingFeatures = 0;
 160      out_properties->bufferFeatures = 0;
 161      return;
 162    }
 163
 164    if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 165                                                      PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_DEPTH_STENCIL)) {
 166       out_properties->linearTilingFeatures = 0;
 167       out_properties->optimalTilingFeatures = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
 168          VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
 169          VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
 170
 171       out_properties->bufferFeatures = 0;
 172       return;
 173    }
 174
 175    if (util_format_is_compressed(pformat)) {
 176       if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 177                                                         PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
 178          features |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
 179          features |= VK_FORMAT_FEATURE_BLIT_SRC_BIT;
 180          features |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
 181          features |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
 182       }
 183       out_properties->linearTilingFeatures = features;
 184       out_properties->optimalTilingFeatures = features;
 185       out_properties->bufferFeatures = buffer_features;
 186       return;
 187    }
 188    buffer_features = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
 189    if (!util_format_is_srgb(pformat) &&
 190        physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 191                                                      PIPE_BUFFER, 0, 0, PIPE_BIND_VERTEX_BUFFER)) {
 192       buffer_features |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
 193    }
 194
 195    if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 196                                                      PIPE_BUFFER, 0, 0, PIPE_BIND_CONSTANT_BUFFER)) {
 197       buffer_features |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
 198    }
 199
 200
 201    if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 202                                                      PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
 203       features |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
 204       features |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
 205    }
 206
 207    if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
 208                                                      PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_RENDER_TARGET)) {
 209       features |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
 210       features |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
 211       features |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
 212    }
 213
 214    if (pformat == PIPE_FORMAT_R32_UINT || pformat == PIPE_FORMAT_R32_SINT) {
 215       features |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
 216       buffer_features |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
 217    }
 218
 219    if (pformat == PIPE_FORMAT_R11G11B10_FLOAT || pformat == PIPE_FORMAT_R9G9B9E5_FLOAT)
 220      features |= VK_FORMAT_FEATURE_BLIT_SRC_BIT;
 221
 222    features |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
 223    if (pformat == PIPE_FORMAT_B5G6R5_UNORM)
 224      features |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
 225    if ((pformat != PIPE_FORMAT_R9G9B9E5_FLOAT) && util_format_get_nr_components(pformat) != 3) {
 226       features |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
 227    }
 228    out_properties->linearTilingFeatures = features;
 229    out_properties->optimalTilingFeatures = features;
 230    out_properties->bufferFeatures = buffer_features;
 231    return;
 232 }
 233
 234 void val_GetPhysicalDeviceFormatProperties(
 235     VkPhysicalDevice                            physicalDevice,
 236     VkFormat                                    format,
 237     VkFormatProperties*                         pFormatProperties)
 238 {
 239    VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice);
 240
 241    val_physical_device_get_format_properties(physical_device,
 242                                              format,
 243                                              pFormatProperties);
 244 }
 245
 246 void val_GetPhysicalDeviceFormatProperties2(
 247         VkPhysicalDevice                            physicalDevice,
 248         VkFormat                                    format,
 249         VkFormatProperties2*                        pFormatProperties)
 250 {
 251    VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice);
 252
 253    val_physical_device_get_format_properties(physical_device,
 254                                              format,
 255                                              &pFormatProperties->formatProperties);
 256 }
 257 static VkResult val_get_image_format_properties(struct val_physical_device *physical_device,
 258                                                  const VkPhysicalDeviceImageFormatInfo2 *info,
 259                                                  VkImageFormatProperties *pImageFormatProperties)
 260 {
 261    VkFormatProperties format_props;
 262    VkFormatFeatureFlags format_feature_flags;
 263    VkExtent3D maxExtent;
 264    uint32_t maxMipLevels;
 265    uint32_t maxArraySize;
 266    VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
 267    enum pipe_format pformat = vk_format_to_pipe(info->format);
 268    val_physical_device_get_format_properties(physical_device, info->format,
 269                                              &format_props);
 270    if (info->tiling == VK_IMAGE_TILING_LINEAR) {
 271       format_feature_flags = format_props.linearTilingFeatures;
 272    } else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) {
 273       format_feature_flags = format_props.optimalTilingFeatures;
 274    } else {
 275       unreachable("bad VkImageTiling");
 276    }
 277
 278    if (format_feature_flags == 0)
 279       goto unsupported;
 280
 281    uint32_t max_2d_ext = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
 282    uint32_t max_layers = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
 283    switch (info->type) {
 284    default:
 285       unreachable("bad vkimage type\n");
 286    case VK_IMAGE_TYPE_1D:
 287       if (util_format_is_compressed(pformat))
 288          goto unsupported;
 289
 290       maxExtent.width = max_2d_ext;
 291       maxExtent.height = 1;
 292       maxExtent.depth = 1;
 293       maxMipLevels = util_logbase2(max_2d_ext);
 294       maxArraySize = max_layers;
 295       break;
 296    case VK_IMAGE_TYPE_2D:
 297       maxExtent.width = max_2d_ext;
 298       maxExtent.height = max_2d_ext;
 299       maxExtent.depth = 1;
 300       maxMipLevels = util_logbase2(max_2d_ext);
 301       maxArraySize = max_layers;
 302       sampleCounts |= VK_SAMPLE_COUNT_4_BIT;
 303       break;
 304    case VK_IMAGE_TYPE_3D:
 305       maxExtent.width = max_2d_ext;
 306       maxExtent.height = max_2d_ext;
 307       maxExtent.depth = (1 << physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS));
 308       maxMipLevels = util_logbase2(max_2d_ext);
 309       maxArraySize = 1;
 310       break;
 311    }
 312
 313    if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
 314       if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
 315          goto unsupported;
 316       }
 317    }
 318
 319    if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) {
 320       if (!(format_feature_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
 321          goto unsupported;
 322       }
 323    }
 324
 325    if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
 326       if (!(format_feature_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
 327          goto unsupported;
 328       }
 329    }
 330
 331    if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
 332       if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
 333          goto unsupported;
 334       }
 335    }
 336
 337    if (info->usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
 338       if (!(format_feature_flags & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) {
 339          goto unsupported;
 340       }
 341    }
 342
 343    if (info->usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
 344       if (!(format_feature_flags & VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) {
 345          goto unsupported;
 346       }
 347    }
 348
 349    if (info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
 350       if (!(format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
 351                                     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))) {
 352          goto unsupported;
 353       }
 354    }
 355
 356    *pImageFormatProperties = (VkImageFormatProperties) {
 357       .maxExtent = maxExtent,
 358       .maxMipLevels = maxMipLevels,
 359       .maxArrayLayers = maxArraySize,
 360       .sampleCounts = sampleCounts,
 361
 362       /* FINISHME: Accurately calculate
 363        * VkImageFormatProperties::maxResourceSize.
 364        */
 365       .maxResourceSize = UINT32_MAX,
 366    };
 367    return VK_SUCCESS;
 368  unsupported:
 369    *pImageFormatProperties = (VkImageFormatProperties) {
 370       .maxExtent = { 0, 0, 0 },
 371       .maxMipLevels = 0,
 372       .maxArrayLayers = 0,
 373       .sampleCounts = 0,
 374       .maxResourceSize = 0,
 375    };
 376
 377    return VK_ERROR_FORMAT_NOT_SUPPORTED;
 378 }
 379
 380 VkResult val_GetPhysicalDeviceImageFormatProperties(
 381     VkPhysicalDevice                            physicalDevice,
 382     VkFormat                                    format,
 383     VkImageType                                 type,
 384     VkImageTiling                               tiling,
 385     VkImageUsageFlags                           usage,
 386     VkImageCreateFlags                          createFlags,
 387     VkImageFormatProperties*                    pImageFormatProperties)
 388 {
 389    VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice);
 390
 391    const VkPhysicalDeviceImageFormatInfo2 info = {
 392       .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
 393       .pNext = NULL,
 394       .format = format,
 395       .type = type,
 396       .tiling = tiling,
 397       .usage = usage,
 398       .flags = createFlags,
 399    };
 400
 401    return val_get_image_format_properties(physical_device, &info,
 402                                            pImageFormatProperties);
 403 }
 404
 405 VkResult val_GetPhysicalDeviceImageFormatProperties2(
 406         VkPhysicalDevice                            physicalDevice,
 407         const VkPhysicalDeviceImageFormatInfo2     *base_info,
 408         VkImageFormatProperties2                   *base_props)
 409 {
 410    VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice);
 411    VkResult result;
 412    result = val_get_image_format_properties(physical_device, base_info,
 413                                              &base_props->imageFormatProperties);
 414    if (result != VK_SUCCESS)
 415       return result;
 416
 417    return VK_SUCCESS;
 418 }
 419
 420 void val_GetPhysicalDeviceSparseImageFormatProperties(
 421     VkPhysicalDevice                            physicalDevice,
 422     VkFormat                                    format,
 423     VkImageType                                 type,
 424     uint32_t                                    samples,
 425     VkImageUsageFlags                           usage,
 426     VkImageTiling                               tiling,
 427     uint32_t*                                   pNumProperties,
 428     VkSparseImageFormatProperties*              pProperties)
 429 {
 430    /* Sparse images are not yet supported. */
 431    *pNumProperties = 0;
 432 }
 433
 434 void val_GetPhysicalDeviceSparseImageFormatProperties2(
 435         VkPhysicalDevice                            physicalDevice,
 436         const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
 437         uint32_t                                   *pPropertyCount,
 438         VkSparseImageFormatProperties2             *pProperties)
 439 {
 440         /* Sparse images are not yet supported. */
 441         *pPropertyCount = 0;
 442 }