mesa/src/vulkan/runtime/vk_image.c

838 lines
30 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright © 2021 Intel Corporation
*
* 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_image.h"
#include <vulkan/vulkan_android.h>
#ifndef _WIN32
#include <drm-uapi/drm_fourcc.h>
#endif
#include "vk_alloc.h"
#include "vk_common_entrypoints.h"
#include "vk_device.h"
#include "vk_format.h"
#include "vk_render_pass.h"
#include "vk_util.h"
#include "vulkan/wsi/wsi_common.h"
static VkExtent3D
sanitize_image_extent(const VkImageType imageType,
const VkExtent3D imageExtent)
{
switch (imageType) {
case VK_IMAGE_TYPE_1D:
return (VkExtent3D) { imageExtent.width, 1, 1 };
case VK_IMAGE_TYPE_2D:
return (VkExtent3D) { imageExtent.width, imageExtent.height, 1 };
case VK_IMAGE_TYPE_3D:
return imageExtent;
default:
unreachable("invalid image type");
}
}
void
vk_image_init(struct vk_device *device,
struct vk_image *image,
const VkImageCreateInfo *pCreateInfo)
{
vk_object_base_init(device, &image->base, VK_OBJECT_TYPE_IMAGE);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
assert(pCreateInfo->mipLevels > 0);
assert(pCreateInfo->arrayLayers > 0);
assert(pCreateInfo->samples > 0);
assert(pCreateInfo->extent.width > 0);
assert(pCreateInfo->extent.height > 0);
assert(pCreateInfo->extent.depth > 0);
if (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
assert(pCreateInfo->imageType == VK_IMAGE_TYPE_2D);
if (pCreateInfo->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT)
assert(pCreateInfo->imageType == VK_IMAGE_TYPE_3D);
image->create_flags = pCreateInfo->flags;
image->image_type = pCreateInfo->imageType;
vk_image_set_format(image, pCreateInfo->format);
image->extent = sanitize_image_extent(pCreateInfo->imageType,
pCreateInfo->extent);
image->mip_levels = pCreateInfo->mipLevels;
image->array_layers = pCreateInfo->arrayLayers;
image->samples = pCreateInfo->samples;
image->tiling = pCreateInfo->tiling;
image->usage = pCreateInfo->usage;
if (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT) {
const VkImageStencilUsageCreateInfo *stencil_usage_info =
vk_find_struct_const(pCreateInfo->pNext,
IMAGE_STENCIL_USAGE_CREATE_INFO);
image->stencil_usage =
stencil_usage_info ? stencil_usage_info->stencilUsage :
pCreateInfo->usage;
} else {
image->stencil_usage = 0;
}
const VkExternalMemoryImageCreateInfo *ext_mem_info =
vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
if (ext_mem_info)
image->external_handle_types = ext_mem_info->handleTypes;
else
image->external_handle_types = 0;
const struct wsi_image_create_info *wsi_info =
vk_find_struct_const(pCreateInfo->pNext, WSI_IMAGE_CREATE_INFO_MESA);
image->wsi_legacy_scanout = wsi_info && wsi_info->scanout;
#ifndef _WIN32
image->drm_format_mod = ((1ULL << 56) - 1) /* DRM_FORMAT_MOD_INVALID */;
#endif
#ifdef ANDROID
const VkExternalFormatANDROID *ext_format =
vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_FORMAT_ANDROID);
if (ext_format && ext_format->externalFormat != 0) {
assert(image->format == VK_FORMAT_UNDEFINED);
assert(image->external_handle_types &
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID);
image->android_external_format = ext_format->externalFormat;
} else {
image->android_external_format = 0;
}
#endif
}
void *
vk_image_create(struct vk_device *device,
const VkImageCreateInfo *pCreateInfo,
const VkAllocationCallbacks *alloc,
size_t size)
{
struct vk_image *image =
vk_zalloc2(&device->alloc, alloc, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (image == NULL)
return NULL;
vk_image_init(device, image, pCreateInfo);
return image;
}
void
vk_image_finish(struct vk_image *image)
{
vk_object_base_finish(&image->base);
}
void
vk_image_destroy(struct vk_device *device,
const VkAllocationCallbacks *alloc,
struct vk_image *image)
{
vk_object_free(device, alloc, image);
}
#ifndef _WIN32
VKAPI_ATTR VkResult VKAPI_CALL
vk_common_GetImageDrmFormatModifierPropertiesEXT(UNUSED VkDevice device,
VkImage _image,
VkImageDrmFormatModifierPropertiesEXT *pProperties)
{
VK_FROM_HANDLE(vk_image, image, _image);
assert(pProperties->sType ==
VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
assert(image->tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT);
pProperties->drmFormatModifier = image->drm_format_mod;
return VK_SUCCESS;
}
#endif
void
vk_image_set_format(struct vk_image *image, VkFormat format)
{
image->format = format;
image->aspects = vk_format_aspects(format);
}
VkImageUsageFlags
vk_image_usage(const struct vk_image *image,
VkImageAspectFlags aspect_mask)
{
assert(!(aspect_mask & ~image->aspects));
/* From the Vulkan 1.2.131 spec:
*
* "If the image was has a depth-stencil format and was created with
* a VkImageStencilUsageCreateInfo structure included in the pNext
* chain of VkImageCreateInfo, the usage is calculated based on the
* subresource.aspectMask provided:
*
* - If aspectMask includes only VK_IMAGE_ASPECT_STENCIL_BIT, the
* implicit usage is equal to
* VkImageStencilUsageCreateInfo::stencilUsage.
*
* - If aspectMask includes only VK_IMAGE_ASPECT_DEPTH_BIT, the
* implicit usage is equal to VkImageCreateInfo::usage.
*
* - If both aspects are included in aspectMask, the implicit usage
* is equal to the intersection of VkImageCreateInfo::usage and
* VkImageStencilUsageCreateInfo::stencilUsage.
*/
if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) {
return image->stencil_usage;
} else if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT)) {
return image->usage & image->stencil_usage;
} else {
/* This also handles the color case */
return image->usage;
}
}
#define VK_IMAGE_ASPECT_ANY_COLOR_MASK_MESA ( \
VK_IMAGE_ASPECT_COLOR_BIT | \
VK_IMAGE_ASPECT_PLANE_0_BIT | \
VK_IMAGE_ASPECT_PLANE_1_BIT | \
VK_IMAGE_ASPECT_PLANE_2_BIT)
/** Expands the given aspect mask relative to the image
*
* If the image has color plane aspects VK_IMAGE_ASPECT_COLOR_BIT has been
* requested, this returns the aspects of the underlying image.
*
* For example,
*
* VK_IMAGE_ASPECT_COLOR_BIT
*
* will be converted to
*
* VK_IMAGE_ASPECT_PLANE_0_BIT |
* VK_IMAGE_ASPECT_PLANE_1_BIT |
* VK_IMAGE_ASPECT_PLANE_2_BIT
*
* for an image of format VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM.
*/
VkImageAspectFlags
vk_image_expand_aspect_mask(const struct vk_image *image,
VkImageAspectFlags aspect_mask)
{
if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {
assert(image->aspects & VK_IMAGE_ASPECT_ANY_COLOR_MASK_MESA);
return image->aspects;
} else {
assert(aspect_mask && !(aspect_mask & ~image->aspects));
return aspect_mask;
}
}
VkExtent3D
vk_image_extent_to_elements(const struct vk_image *image, VkExtent3D extent)
{
const struct util_format_description *fmt =
vk_format_description(image->format);
extent = vk_image_sanitize_extent(image, extent);
extent.width = DIV_ROUND_UP(extent.width, fmt->block.width);
extent.height = DIV_ROUND_UP(extent.height, fmt->block.height);
extent.depth = DIV_ROUND_UP(extent.depth, fmt->block.depth);
return extent;
}
VkOffset3D
vk_image_offset_to_elements(const struct vk_image *image, VkOffset3D offset)
{
const struct util_format_description *fmt =
vk_format_description(image->format);
offset = vk_image_sanitize_offset(image, offset);
assert(offset.x % fmt->block.width == 0);
assert(offset.y % fmt->block.height == 0);
assert(offset.z % fmt->block.depth == 0);
offset.x /= fmt->block.width;
offset.y /= fmt->block.height;
offset.z /= fmt->block.depth;
return offset;
}
struct vk_image_buffer_layout
vk_image_buffer_copy_layout(const struct vk_image *image,
const VkBufferImageCopy2* region)
{
VkExtent3D extent = vk_image_sanitize_extent(image, region->imageExtent);
const uint32_t row_length = region->bufferRowLength ?
region->bufferRowLength : extent.width;
const uint32_t image_height = region->bufferImageHeight ?
region->bufferImageHeight : extent.height;
const VkImageAspectFlags aspect = region->imageSubresource.aspectMask;
VkFormat format = vk_format_get_aspect_format(image->format, aspect);
const struct util_format_description *fmt = vk_format_description(format);
assert(fmt->block.bits % 8 == 0);
const uint32_t element_size_B = fmt->block.bits / 8;
const uint32_t row_stride_B =
DIV_ROUND_UP(row_length, fmt->block.width) * element_size_B;
const uint64_t image_stride_B =
DIV_ROUND_UP(image_height, fmt->block.height) * (uint64_t)row_stride_B;
return (struct vk_image_buffer_layout) {
.row_length = row_length,
.image_height = image_height,
.element_size_B = element_size_B,
.row_stride_B = row_stride_B,
.image_stride_B = image_stride_B,
};
}
static VkComponentSwizzle
remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component)
{
return swizzle == VK_COMPONENT_SWIZZLE_IDENTITY ? component : swizzle;
}
void
vk_image_view_init(struct vk_device *device,
struct vk_image_view *image_view,
bool driver_internal,
const VkImageViewCreateInfo *pCreateInfo)
{
vk_object_base_init(device, &image_view->base, VK_OBJECT_TYPE_IMAGE_VIEW);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
VK_FROM_HANDLE(vk_image, image, pCreateInfo->image);
image_view->create_flags = pCreateInfo->flags;
image_view->image = image;
image_view->view_type = pCreateInfo->viewType;
image_view->format = pCreateInfo->format;
if (!driver_internal) {
switch (image_view->view_type) {
case VK_IMAGE_VIEW_TYPE_1D:
case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
assert(image->image_type == VK_IMAGE_TYPE_1D);
break;
case VK_IMAGE_VIEW_TYPE_2D:
case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
if (image->create_flags & (VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT |
VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT))
assert(image->image_type == VK_IMAGE_TYPE_3D);
else
assert(image->image_type == VK_IMAGE_TYPE_2D);
break;
case VK_IMAGE_VIEW_TYPE_3D:
assert(image->image_type == VK_IMAGE_TYPE_3D);
break;
case VK_IMAGE_VIEW_TYPE_CUBE:
case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
assert(image->image_type == VK_IMAGE_TYPE_2D);
assert(image->create_flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT);
break;
default:
unreachable("Invalid image view type");
}
}
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
if (driver_internal) {
/* For driver internal images, all we require is that the block sizes
* match. Otherwise, we trust the driver to use a format it knows what
* to do with. Combined depth/stencil images might not match if the
* driver only cares about one of the two aspects.
*/
if (image->aspects == VK_IMAGE_ASPECT_COLOR_BIT ||
image->aspects == VK_IMAGE_ASPECT_DEPTH_BIT ||
image->aspects == VK_IMAGE_ASPECT_STENCIL_BIT) {
assert(vk_format_get_blocksize(image->format) ==
vk_format_get_blocksize(image_view->format));
}
image_view->aspects = range->aspectMask;
image_view->view_format = pCreateInfo->format;
} else {
image_view->aspects =
vk_image_expand_aspect_mask(image, range->aspectMask);
/* From the Vulkan 1.2.184 spec:
*
* "If the image has a multi-planar format and
* subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, and image
* has been created with a usage value not containing any of the
* VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
* VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR,
* VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
* VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR,
* VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, and
* VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR flags, then the format must
* be identical to the image format, and the sampler to be used with the
* image view must enable sampler YCBCR conversion."
*
* Since no one implements video yet, we can ignore the bits about video
* create flags and assume YCbCr formats match.
*/
if ((image->aspects & VK_IMAGE_ASPECT_PLANE_1_BIT) &&
(range->aspectMask == VK_IMAGE_ASPECT_COLOR_BIT))
assert(pCreateInfo->format == image->format);
/* From the Vulkan 1.2.184 spec:
*
* "Each depth/stencil format is only compatible with itself."
*/
if (image_view->aspects & (VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT))
assert(pCreateInfo->format == image->format);
if (!(image->create_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT))
assert(pCreateInfo->format == image->format);
/* Restrict the format to only the planes chosen.
*
* For combined depth and stencil images, this means the depth-only or
* stencil-only format if only one aspect is chosen and the full
* combined format if both aspects are chosen.
*
* For single-plane color images, we just take the format as-is. For
* multi-plane views of multi-plane images, this means we want the full
* multi-plane format. For single-plane views of multi-plane images, we
* want a format compatible with the one plane. Fortunately, this is
* already what the client gives us. The Vulkan 1.2.184 spec says:
*
* "If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
* and the image has a multi-planar format, and if
* subresourceRange.aspectMask is VK_IMAGE_ASPECT_PLANE_0_BIT,
* VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT,
* format must be compatible with the corresponding plane of the
* image, and the sampler to be used with the image view must not
* enable sampler YCBCR conversion."
*/
if (image_view->aspects == VK_IMAGE_ASPECT_STENCIL_BIT) {
image_view->view_format = vk_format_stencil_only(pCreateInfo->format);
} else if (image_view->aspects == VK_IMAGE_ASPECT_DEPTH_BIT) {
image_view->view_format = vk_format_depth_only(pCreateInfo->format);
} else {
image_view->view_format = pCreateInfo->format;
}
}
image_view->swizzle = (VkComponentMapping) {
.r = remap_swizzle(pCreateInfo->components.r, VK_COMPONENT_SWIZZLE_R),
.g = remap_swizzle(pCreateInfo->components.g, VK_COMPONENT_SWIZZLE_G),
.b = remap_swizzle(pCreateInfo->components.b, VK_COMPONENT_SWIZZLE_B),
.a = remap_swizzle(pCreateInfo->components.a, VK_COMPONENT_SWIZZLE_A),
};
assert(range->layerCount > 0);
assert(range->baseMipLevel < image->mip_levels);
image_view->base_mip_level = range->baseMipLevel;
image_view->level_count = vk_image_subresource_level_count(image, range);
image_view->base_array_layer = range->baseArrayLayer;
image_view->layer_count = vk_image_subresource_layer_count(image, range);
const VkImageViewMinLodCreateInfoEXT *min_lod_info =
vk_find_struct_const(pCreateInfo, IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT);
image_view->min_lod = min_lod_info ? min_lod_info->minLod : 0.0f;
/* From the Vulkan 1.3.215 spec:
*
* VUID-VkImageViewMinLodCreateInfoEXT-minLod-06456
*
* "minLod must be less or equal to the index of the last mipmap level
* accessible to the view."
*/
assert(image_view->min_lod <= image_view->base_mip_level +
image_view->level_count - 1);
image_view->extent =
vk_image_mip_level_extent(image, image_view->base_mip_level);
assert(image_view->base_mip_level + image_view->level_count
<= image->mip_levels);
switch (image->image_type) {
default:
unreachable("bad VkImageType");
case VK_IMAGE_TYPE_1D:
case VK_IMAGE_TYPE_2D:
assert(image_view->base_array_layer + image_view->layer_count
<= image->array_layers);
break;
case VK_IMAGE_TYPE_3D:
assert(image_view->base_array_layer + image_view->layer_count
<= image_view->extent.depth);
break;
}
/* If we are creating a color view from a depth/stencil image we compute
* usage from the underlying depth/stencil aspects.
*/
const VkImageUsageFlags image_usage =
vk_image_usage(image, image_view->aspects);
const VkImageViewUsageCreateInfo *usage_info =
vk_find_struct_const(pCreateInfo, IMAGE_VIEW_USAGE_CREATE_INFO);
image_view->usage = usage_info ? usage_info->usage : image_usage;
assert(driver_internal || !(image_view->usage & ~image_usage));
}
void
vk_image_view_finish(struct vk_image_view *image_view)
{
vk_object_base_finish(&image_view->base);
}
void *
vk_image_view_create(struct vk_device *device,
bool driver_internal,
const VkImageViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *alloc,
size_t size)
{
struct vk_image_view *image_view =
vk_zalloc2(&device->alloc, alloc, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (image_view == NULL)
return NULL;
vk_image_view_init(device, image_view, driver_internal, pCreateInfo);
return image_view;
}
void
vk_image_view_destroy(struct vk_device *device,
const VkAllocationCallbacks *alloc,
struct vk_image_view *image_view)
{
vk_object_free(device, alloc, image_view);
}
bool
vk_image_layout_is_read_only(VkImageLayout layout,
VkImageAspectFlagBits aspect)
{
assert(util_bitcount(aspect) == 1);
switch (layout) {
case VK_IMAGE_LAYOUT_UNDEFINED:
case VK_IMAGE_LAYOUT_PREINITIALIZED:
return true; /* These are only used for layout transitions */
case VK_IMAGE_LAYOUT_GENERAL:
case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch"
#endif
case VK_IMAGE_LAYOUT_SUBPASS_SELF_DEPENDENCY_MESA:
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
return false;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
return true;
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
return aspect == VK_IMAGE_ASPECT_DEPTH_BIT;
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
return aspect == VK_IMAGE_ASPECT_STENCIL_BIT;
case VK_IMAGE_LAYOUT_MAX_ENUM:
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
#endif
unreachable("Invalid image layout.");
}
unreachable("Invalid image layout.");
}
bool
vk_image_layout_is_depth_only(VkImageLayout layout)
{
switch (layout) {
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
return true;
default:
return false;
}
}
/* From the Vulkan Specification 1.2.166 - VkAttachmentReference2:
*
* "If layout only specifies the layout of the depth aspect of the
* attachment, the layout of the stencil aspect is specified by the
* stencilLayout member of a VkAttachmentReferenceStencilLayout structure
* included in the pNext chain. Otherwise, layout describes the layout for
* all relevant image aspects."
*/
VkImageLayout
vk_att_ref_stencil_layout(const VkAttachmentReference2 *att_ref,
const VkAttachmentDescription2 *attachments)
{
/* From VUID-VkAttachmentReference2-attachment-04755:
* "If attachment is not VK_ATTACHMENT_UNUSED, and the format of the
* referenced attachment is a depth/stencil format which includes both
* depth and stencil aspects [...]
*/
if (att_ref->attachment == VK_ATTACHMENT_UNUSED ||
!vk_format_has_stencil(attachments[att_ref->attachment].format))
return VK_IMAGE_LAYOUT_UNDEFINED;
const VkAttachmentReferenceStencilLayout *stencil_ref =
vk_find_struct_const(att_ref->pNext, ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
if (stencil_ref)
return stencil_ref->stencilLayout;
/* From VUID-VkAttachmentReference2-attachment-04755:
* "If attachment is not VK_ATTACHMENT_UNUSED, and the format of the
* referenced attachment is a depth/stencil format which includes both
* depth and stencil aspects, and layout is
* VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or
* VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include
* a VkAttachmentReferenceStencilLayout structure."
*/
assert(!vk_image_layout_is_depth_only(att_ref->layout));
return att_ref->layout;
}
/* From the Vulkan Specification 1.2.184:
*
* "If the pNext chain includes a VkAttachmentDescriptionStencilLayout
* structure, then the stencilInitialLayout and stencilFinalLayout members
* specify the initial and final layouts of the stencil aspect of a
* depth/stencil format, and initialLayout and finalLayout only apply to the
* depth aspect. For depth-only formats, the
* VkAttachmentDescriptionStencilLayout structure is ignored. For
* stencil-only formats, the initial and final layouts of the stencil aspect
* are taken from the VkAttachmentDescriptionStencilLayout structure if
* present, or initialLayout and finalLayout if not present."
*
* "If format is a depth/stencil format, and either initialLayout or
* finalLayout does not specify a layout for the stencil aspect, then the
* application must specify the initial and final layouts of the stencil
* aspect by including a VkAttachmentDescriptionStencilLayout structure in
* the pNext chain."
*/
VkImageLayout
vk_att_desc_stencil_layout(const VkAttachmentDescription2 *att_desc, bool final)
{
if (!vk_format_has_stencil(att_desc->format))
return VK_IMAGE_LAYOUT_UNDEFINED;
const VkAttachmentDescriptionStencilLayout *stencil_desc =
vk_find_struct_const(att_desc->pNext, ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
if (stencil_desc) {
return final ?
stencil_desc->stencilFinalLayout :
stencil_desc->stencilInitialLayout;
}
const VkImageLayout main_layout =
final ? att_desc->finalLayout : att_desc->initialLayout;
/* From VUID-VkAttachmentDescription2-format-03302/03303:
* "If format is a depth/stencil format which includes both depth and
* stencil aspects, and initial/finalLayout is
* VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or
* VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include
* a VkAttachmentDescriptionStencilLayout structure."
*/
assert(!vk_image_layout_is_depth_only(main_layout));
return main_layout;
}
VkImageUsageFlags
vk_image_layout_to_usage_flags(VkImageLayout layout,
VkImageAspectFlagBits aspect)
{
assert(util_bitcount(aspect) == 1);
switch (layout) {
case VK_IMAGE_LAYOUT_UNDEFINED:
case VK_IMAGE_LAYOUT_PREINITIALIZED:
return 0u;
case VK_IMAGE_LAYOUT_GENERAL:
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch"
#endif
case VK_IMAGE_LAYOUT_SUBPASS_SELF_DEPENDENCY_MESA:
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
return ~0u;
case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
assert(aspect & VK_IMAGE_ASPECT_ANY_COLOR_MASK_MESA);
return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
assert(aspect & (VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT));
return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
assert(aspect & VK_IMAGE_ASPECT_DEPTH_BIT);
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, aspect);
case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
assert(aspect & VK_IMAGE_ASPECT_STENCIL_BIT);
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, aspect);
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
assert(aspect & (VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT));
return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
assert(aspect & VK_IMAGE_ASPECT_DEPTH_BIT);
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, aspect);
case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
assert(aspect & VK_IMAGE_ASPECT_STENCIL_BIT);
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, aspect);
case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
return VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT) {
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, aspect);
} else if (aspect == VK_IMAGE_ASPECT_STENCIL_BIT) {
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, aspect);
} else {
assert(!"Must be a depth/stencil aspect");
return 0;
}
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT) {
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, aspect);
} else if (aspect == VK_IMAGE_ASPECT_STENCIL_BIT) {
return vk_image_layout_to_usage_flags(
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, aspect);
} else {
assert(!"Must be a depth/stencil aspect");
return 0;
}
case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
/* This needs to be handled specially by the caller */
return 0;
case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return vk_image_layout_to_usage_flags(VK_IMAGE_LAYOUT_GENERAL, aspect);
case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT;
case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT ||
aspect == VK_IMAGE_ASPECT_STENCIL_BIT) {
return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
} else {
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
}
case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
return VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
case VK_IMAGE_LAYOUT_MAX_ENUM:
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
#endif
unreachable("Invalid image layout.");
}
unreachable("Invalid image layout.");
}