KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tu: Use common vk_image struct 

This eliminates some boilerplate, and will be necessary to use the
common render pass implementation for debugging purposes.

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17378>
This commit is contained in:
Connor Abbott 2022-07-18 12:30:59 +02:00 committed by Marge Bot
parent cb0f414b2a
commit 89263fde20
5 changed files with 1179 additions and 1234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/freedreno/vulkan/tu_autotune.c
View File

@ -151,9 +151,9 @@ hash_renderpass_instance(const struct tu_render_pass *pass,
for (unsigned i = 0; i < pass->attachment_count; i++) {
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->view.width);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->view.height);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->vk_format);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->layer_count);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->level_count);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->vk.format);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->vk.array_layers);
APPEND_TO_HASH(&hash_state, cmd->state.attachments[i]->image->vk.mip_levels);
}
APPEND_TO_HASH(&hash_state, pass->subpass_count);

88
src/freedreno/vulkan/tu_clear_blit.c
View File

@ -1463,7 +1463,7 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
}
const struct fdl_layout *layout =
&image->layout[tu6_plane_index(image->vk_format, aspect_mask)];
&image->layout[tu6_plane_index(image->vk.format, aspect_mask)];
fdl6_view_init(iview, &layout, &(struct fdl_view_args) {
.iova = image->iova,
@ -1496,7 +1496,7 @@ tu_image_view_blit(struct fdl6_view *iview,
uint32_t layer)
{
enum pipe_format format =
tu6_plane_format(image->vk_format, tu6_plane_index(image->vk_format,
tu6_plane_format(image->vk.format, tu6_plane_index(image->vk.format,
subres->aspectMask));
tu_image_view_copy_blit(iview, image, format, subres, layer, false);
}
@ -1554,8 +1554,8 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
unsigned blit_param = rotate[mirror_y][mirror_x];
if (dst_image->layout[0].nr_samples > 1 ||
src_image->vk_format == VK_FORMAT_BC1_RGB_UNORM_BLOCK ||
src_image->vk_format == VK_FORMAT_BC1_RGB_SRGB_BLOCK ||
src_image->vk.format == VK_FORMAT_BC1_RGB_UNORM_BLOCK ||
src_image->vk.format == VK_FORMAT_BC1_RGB_SRGB_BLOCK ||
filter == VK_FILTER_CUBIC_EXT ||
z_scale) {
ops = &r3d_ops;
@ -1566,12 +1566,12 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
* TODO: this probably should use a helper
*/
enum pipe_format src_format =
tu6_plane_format(src_image->vk_format,
tu6_plane_index(src_image->vk_format,
tu6_plane_format(src_image->vk.format,
tu6_plane_index(src_image->vk.format,
info->srcSubresource.aspectMask));
enum pipe_format dst_format =
tu6_plane_format(dst_image->vk_format,
tu6_plane_index(src_image->vk_format,
tu6_plane_format(dst_image->vk.format,
tu6_plane_index(src_image->vk.format,
info->srcSubresource.aspectMask));
trace_start_blit(&cmd->trace, cs);
@ -1626,8 +1626,8 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
trace_end_blit(&cmd->trace, cs,
ops == &r3d_ops,
src_image->vk_format,
dst_image->vk_format,
src_image->vk.format,
dst_image->vk.format,
layers);
}
@ -1644,8 +1644,8 @@ tu_CmdBlitImage2KHR(VkCommandBuffer commandBuffer,
/* can't blit both depth and stencil at once with D32_S8
* TODO: more advanced 3D blit path to support it instead?
*/
if (src_image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
dst_image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (src_image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
dst_image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
VkImageBlit2 region = pBlitImageInfo->pRegions[i];
u_foreach_bit(b, region.dstSubresource.aspectMask) {
region.srcSubresource.aspectMask = BIT(b);
@ -1698,13 +1698,13 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
struct tu_cs *cs = &cmd->cs;
uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
enum pipe_format src_format =
copy_format(dst_image->vk_format, info->imageSubresource.aspectMask);
copy_format(dst_image->vk.format, info->imageSubresource.aspectMask);
enum pipe_format dst_format =
copy_format(dst_image->vk_format, info->imageSubresource.aspectMask);
copy_format(dst_image->vk.format, info->imageSubresource.aspectMask);
const struct blit_ops *ops = &r2d_ops;
/* special case for buffer to stencil */
if (dst_image->vk_format == VK_FORMAT_D24_UNORM_S8_UINT &&
if (dst_image->vk.format == VK_FORMAT_D24_UNORM_S8_UINT &&
info->imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) {
src_format = PIPE_FORMAT_S8_UINT;
}
@ -1718,7 +1718,7 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
uint32_t src_width = info->bufferRowLength ?: extent.width;
uint32_t src_height = info->bufferImageHeight ?: extent.height;
copy_compressed(dst_image->vk_format, &offset, &extent, &src_width, &src_height);
copy_compressed(dst_image->vk.format, &offset, &extent, &src_width, &src_height);
uint32_t pitch = src_width * util_format_get_blocksize(src_format);
uint32_t layer_size = src_height * pitch;
@ -1780,12 +1780,12 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
struct tu_cs *cs = &cmd->cs;
uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
enum pipe_format dst_format =
copy_format(src_image->vk_format, info->imageSubresource.aspectMask);
copy_format(src_image->vk.format, info->imageSubresource.aspectMask);
enum pipe_format src_format =
copy_format(src_image->vk_format, info->imageSubresource.aspectMask);
copy_format(src_image->vk.format, info->imageSubresource.aspectMask);
const struct blit_ops *ops = &r2d_ops;
if (src_image->vk_format == VK_FORMAT_D24_UNORM_S8_UINT &&
if (src_image->vk.format == VK_FORMAT_D24_UNORM_S8_UINT &&
info->imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) {
dst_format = PIPE_FORMAT_S8_UINT;
}
@ -1799,7 +1799,7 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
uint32_t dst_width = info->bufferRowLength ?: extent.width;
uint32_t dst_height = info->bufferImageHeight ?: extent.height;
copy_compressed(src_image->vk_format, &offset, &extent, &dst_width, &dst_height);
copy_compressed(src_image->vk.format, &offset, &extent, &dst_width, &dst_height);
uint32_t pitch = dst_width * util_format_get_blocksize(dst_format);
uint32_t layer_size = pitch * dst_height;
@ -1872,7 +1872,7 @@ static bool
image_is_r8g8(struct tu_image *image)
{
return image->layout[0].cpp == 2 &&
vk_format_get_nr_components(image->vk_format) == 2;
vk_format_get_nr_components(image->vk.format) == 2;
}
static void
@ -1909,11 +1909,11 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
* This means we only have to adjust the extent if the source image is
* compressed.
*/
copy_compressed(src_image->vk_format, &src_offset, &extent, NULL, NULL);
copy_compressed(dst_image->vk_format, &dst_offset, NULL, NULL, NULL);
copy_compressed(src_image->vk.format, &src_offset, &extent, NULL, NULL);
copy_compressed(dst_image->vk.format, &dst_offset, NULL, NULL, NULL);
enum pipe_format dst_format = copy_format(dst_image->vk_format, info->dstSubresource.aspectMask);
enum pipe_format src_format = copy_format(src_image->vk_format, info->srcSubresource.aspectMask);
enum pipe_format dst_format = copy_format(dst_image->vk.format, info->dstSubresource.aspectMask);
enum pipe_format src_format = copy_format(src_image->vk.format, info->srcSubresource.aspectMask);
/* note: could use "R8_UNORM" when no UBWC */
if (dst_format == PIPE_FORMAT_Y8_UNORM ||
@ -2068,7 +2068,7 @@ tu_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_image, dst_image, pCopyImageInfo->dstImage);
for (uint32_t i = 0; i < pCopyImageInfo->regionCount; ++i) {
if (src_image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (src_image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
VkImageCopy2 info = pCopyImageInfo->pRegions[i];
u_foreach_bit(b, info.dstSubresource.aspectMask) {
info.srcSubresource.aspectMask = BIT(b);
@ -2207,9 +2207,9 @@ tu_CmdResolveImage2KHR(VkCommandBuffer commandBuffer,
struct tu_cs *cs = &cmd->cs;
enum pipe_format src_format =
tu_vk_format_to_pipe_format(src_image->vk_format);
tu_vk_format_to_pipe_format(src_image->vk.format);
enum pipe_format dst_format =
tu_vk_format_to_pipe_format(dst_image->vk_format);
tu_vk_format_to_pipe_format(dst_image->vk.format);
ops->setup(cmd, cs, src_format, dst_format,
VK_IMAGE_ASPECT_COLOR_BIT, 0, false, dst_image->layout[0].ubwc,
VK_SAMPLE_COUNT_1_BIT);
@ -2306,12 +2306,12 @@ tu_resolve_sysmem(struct tu_cmd_buffer *cmd,
uint32_t layers,
const VkRect2D *rect)
{
assert(src->image->vk_format == dst->image->vk_format ||
(vk_format_is_depth_or_stencil(src->image->vk_format) &&
vk_format_is_depth_or_stencil(dst->image->vk_format)));
assert(src->image->vk.format == dst->image->vk.format ||
(vk_format_is_depth_or_stencil(src->image->vk.format) &&
vk_format_is_depth_or_stencil(dst->image->vk.format)));
bool src_separate_ds = src->image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT;
bool dst_separate_ds = dst->image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT;
bool src_separate_ds = src->image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT;
bool dst_separate_ds = dst->image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT;
if (dst_separate_ds) {
resolve_sysmem(cmd, cs, VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT,
@ -2321,7 +2321,7 @@ tu_resolve_sysmem(struct tu_cmd_buffer *cmd,
src, dst, layer_mask, layers, rect,
src_separate_ds, dst_separate_ds);
} else {
resolve_sysmem(cmd, cs, src->image->vk_format, dst->image->vk_format,
resolve_sysmem(cmd, cs, src->image->vk.format, dst->image->vk.format,
src, dst, layer_mask, layers, rect,
src_separate_ds, dst_separate_ds);
}
@ -2334,15 +2334,15 @@ clear_image(struct tu_cmd_buffer *cmd,
const VkImageSubresourceRange *range,
VkImageAspectFlags aspect_mask)
{
uint32_t level_count = tu_get_levelCount(image, range);
uint32_t layer_count = tu_get_layerCount(image, range);
uint32_t level_count = vk_image_subresource_level_count(&image->vk, range);
uint32_t layer_count = vk_image_subresource_layer_count(&image->vk, range);
struct tu_cs *cs = &cmd->cs;
enum pipe_format format;
if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
if (image->vk.format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
format = PIPE_FORMAT_R32_UINT;
} else {
format = tu6_plane_format(image->vk_format,
tu6_plane_index(image->vk_format,
format = tu6_plane_format(image->vk.format,
tu6_plane_index(image->vk.format,
aspect_mask));
}
@ -2355,7 +2355,7 @@ clear_image(struct tu_cmd_buffer *cmd,
ops->setup(cmd, cs, format, format, aspect_mask, 0, true, image->layout[0].ubwc,
image->layout[0].nr_samples);
if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
if (image->vk.format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
ops->clear_value(cs, PIPE_FORMAT_R9G9B9E5_FLOAT, clear_value);
else
ops->clear_value(cs, format, clear_value);
@ -2415,7 +2415,7 @@ tu_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
for (unsigned i = 0; i < rangeCount; i++) {
const VkImageSubresourceRange *range = &pRanges[i];
if (image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
/* can't clear both depth and stencil at once, split up the aspect mask */
u_foreach_bit(b, range->aspectMask)
clear_image(cmd, image, (const VkClearValue*) pDepthStencil, range, BIT(b));
@ -2958,7 +2958,7 @@ tu_emit_blit(struct tu_cmd_buffer *cmd,
vk_format_is_depth_or_stencil(attachment->format)));
tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_DST_INFO, 4);
if (iview->image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (iview->image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (!separate_stencil) {
tu_cs_emit(cs, tu_image_view_depth(iview, RB_BLIT_DST_INFO));
tu_cs_emit_qw(cs, iview->depth_base_addr);
@ -3129,7 +3129,7 @@ store_cp_blit(struct tu_cmd_buffer *cmd,
r2d_setup_common(cmd, cs, src_format, dst_format, VK_IMAGE_ASPECT_COLOR_BIT, 0, false,
iview->view.ubwc_enabled, true);
if (iview->image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (iview->image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (!separate_stencil) {
r2d_dst_depth(cs, iview, 0);
} else {
@ -3202,7 +3202,7 @@ store_3d_blit(struct tu_cmd_buffer *cmd,
r3d_coords(cs, &render_area->offset, &render_area->offset, &render_area->extent);
if (iview->image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (iview->image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (!separate_stencil) {
r3d_dst_depth(cs, iview, 0);
} else {

66
src/freedreno/vulkan/tu_image.c
View File

@ -184,7 +184,7 @@ tu_image_view_init(struct tu_image_view *iview,
const struct fdl_layout *layouts[3];
layouts[0] = &image->layout[tu6_plane_index(image->vk_format, aspect_mask)];
layouts[0] = &image->layout[tu6_plane_index(image->vk.format, aspect_mask)];
enum pipe_format format;
if (aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT)
@ -192,7 +192,7 @@ tu_image_view_init(struct tu_image_view *iview,
else
format = tu_vk_format_to_pipe_format(vk_format);
if (image->vk_format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM &&
if (image->vk.format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM &&
aspect_mask == VK_IMAGE_ASPECT_PLANE_0_BIT) {
if (vk_format == VK_FORMAT_R8_UNORM) {
/* The 0'th plane of this format has a different UBWC compression. */
@ -216,8 +216,8 @@ tu_image_view_init(struct tu_image_view *iview,
args.iova = image->iova;
args.base_array_layer = range->baseArrayLayer;
args.base_miplevel = range->baseMipLevel;
args.layer_count = tu_get_layerCount(image, range);
args.level_count = tu_get_levelCount(image, range);
args.layer_count = vk_image_subresource_layer_count(&image->vk, range);
args.level_count = vk_image_subresource_level_count(&image->vk, range);
args.min_lod_clamp = min_lod ? min_lod->minLod : 0.f;
args.format = tu_format_for_aspect(format, aspect_mask);
vk_component_mapping_to_pipe_swizzle(pCreateInfo->components, args.swiz);
@ -258,7 +258,7 @@ tu_image_view_init(struct tu_image_view *iview,
fdl6_view_init(&iview->view, layouts, &args, has_z24uint_s8uint);
if (image->vk_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
struct fdl_layout *layout = &image->layout[0];
iview->depth_base_addr = image->iova +
fdl_surface_offset(layout, range->baseMipLevel, range->baseArrayLayer);
@ -359,13 +359,8 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
const VkImageCreateInfo *pCreateInfo, uint64_t modifier,
const VkSubresourceLayout *plane_layouts)
{
const VkExternalMemoryImageCreateInfo *external_info =
vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
image->shareable = external_info != NULL;
image->vk_format = pCreateInfo->format;
image->level_count = pCreateInfo->mipLevels;
image->layer_count = pCreateInfo->arrayLayers;
vk_image_init(&device->vk, &image->vk, pCreateInfo);
image->vk.drm_format_mod = modifier;
enum a6xx_tile_mode tile_mode = TILE6_3;
bool ubwc_enabled = true;
@ -377,7 +372,7 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
}
/* Force linear tiling for formats with "fake" optimalTilingFeatures */
if (!tiling_possible(image->vk_format)) {
if (!tiling_possible(image->vk.format)) {
tile_mode = TILE6_LINEAR;
ubwc_enabled = false;
}
@ -389,7 +384,7 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
}
enum pipe_format format =
tu_vk_format_to_pipe_format(image->vk_format);
tu_vk_format_to_pipe_format(image->vk.format);
/* Whether a view of the image with an R8G8 format could be made. */
bool has_r8g8 = tu_is_r8g8(format);
@ -406,7 +401,7 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
* - figure out which UBWC compressions are compatible to keep it enabled
*/
if ((pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) &&
!vk_format_is_depth_or_stencil(image->vk_format)) {
!vk_format_is_depth_or_stencil(image->vk.format)) {
const VkImageFormatListCreateInfo *fmt_list =
vk_find_struct_const(pCreateInfo->pNext, IMAGE_FORMAT_LIST_CREATE_INFO);
bool may_be_swapped = true;
@ -451,11 +446,8 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
ubwc_enabled = false;
}
const VkImageStencilUsageCreateInfo *stencil_usage_info =
vk_find_struct_const(pCreateInfo->pNext, IMAGE_STENCIL_USAGE_CREATE_INFO);
if (!ubwc_possible(image->vk_format, pCreateInfo->imageType, pCreateInfo->usage,
stencil_usage_info ? stencil_usage_info->stencilUsage : pCreateInfo->usage,
if (!ubwc_possible(image->vk.format, pCreateInfo->imageType,
pCreateInfo->usage, image->vk.stencil_usage,
device->physical_device->info, pCreateInfo->samples,
device->use_z24uint_s8uint))
ubwc_enabled = false;
@ -475,14 +467,14 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
tile_mode = TILE6_LINEAR;
}
for (uint32_t i = 0; i < tu6_plane_count(image->vk_format); i++) {
for (uint32_t i = 0; i < tu6_plane_count(image->vk.format); i++) {
struct fdl_layout *layout = &image->layout[i];
enum pipe_format format = tu6_plane_format(image->vk_format, i);
enum pipe_format format = tu6_plane_format(image->vk.format, i);
uint32_t width0 = pCreateInfo->extent.width;
uint32_t height0 = pCreateInfo->extent.height;
if (i > 0) {
switch (image->vk_format) {
switch (image->vk.format) {
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
/* half width/height on chroma planes */
@ -714,7 +706,8 @@ tu_get_image_memory_requirements(struct tu_image *image,
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
VkMemoryDedicatedRequirements *req =
(VkMemoryDedicatedRequirements *) ext;
req->requiresDedicatedAllocation = image->shareable;
req->requiresDedicatedAllocation =
image->vk.external_handle_types != 0;
req->prefersDedicatedAllocation = req->requiresDedicatedAllocation;
break;
}
@ -779,7 +772,7 @@ tu_GetImageSubresourceLayout(VkDevice _device,
TU_FROM_HANDLE(tu_image, image, _image);
struct fdl_layout *layout =
&image->layout[tu6_plane_index(image->vk_format, pSubresource->aspectMask)];
&image->layout[tu6_plane_index(image->vk.format, pSubresource->aspectMask)];
const struct fdl_slice *slice = layout->slices + pSubresource->mipLevel;
pLayout->offset =
@ -793,31 +786,10 @@ tu_GetImageSubresourceLayout(VkDevice _device,
/* UBWC starts at offset 0 */
pLayout->offset = 0;
/* UBWC scanout won't match what the kernel wants if we have levels/layers */
assert(image->level_count == 1 && image->layer_count == 1);
assert(image->vk.mip_levels == 1 && image->vk.array_layers == 1);
}
}
VKAPI_ATTR VkResult VKAPI_CALL
tu_GetImageDrmFormatModifierPropertiesEXT(
VkDevice device,
VkImage _image,
VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
TU_FROM_HANDLE(tu_image, image, _image);
/* TODO invent a modifier for tiled but not UBWC buffers */
if (!image->layout[0].tile_mode)
pProperties->drmFormatModifier = DRM_FORMAT_MOD_LINEAR;
else if (image->layout[0].ubwc_layer_size)
pProperties->drmFormatModifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
else
pProperties->drmFormatModifier = DRM_FORMAT_MOD_INVALID;
return VK_SUCCESS;
}
VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateImageView(VkDevice _device,
const VkImageViewCreateInfo *pCreateInfo,

2
src/freedreno/vulkan/tu_lrz.c
View File

@ -544,7 +544,7 @@ tu_lrz_clear_depth_image(struct tu_cmd_buffer *cmd,
tu6_write_lrz_reg(cmd, &cmd->cs, A6XX_GRAS_LRZ_DEPTH_VIEW(
.base_layer = range->baseArrayLayer,
.layer_count = tu_get_layerCount(image, range),
.layer_count = vk_image_subresource_layer_count(&image->vk, range),
.base_mip_level = range->baseMipLevel,
));

31
src/freedreno/vulkan/tu_private.h
View File

@ -2069,14 +2069,7 @@ tu6_base_format(enum pipe_format format)
struct tu_image
{
struct vk_object_base base;
/* The original VkFormat provided by the client. This may not match any
* of the actual surface formats.
*/
VkFormat vk_format;
uint32_t level_count;
uint32_t layer_count;
struct vk_image vk;
struct fdl_layout layout[3];
uint32_t total_size;
@ -2095,28 +2088,8 @@ struct tu_image
uint32_t lrz_offset;
uint32_t lrz_fc_offset;
uint32_t lrz_fc_size;
bool shareable;
};
static inline uint32_t
tu_get_layerCount(const struct tu_image *image,
const VkImageSubresourceRange *range)
{
return range->layerCount == VK_REMAINING_ARRAY_LAYERS
? image->layer_count - range->baseArrayLayer
: range->layerCount;
}
static inline uint32_t
tu_get_levelCount(const struct tu_image *image,
const VkImageSubresourceRange *range)
{
return range->levelCount == VK_REMAINING_MIP_LEVELS
? image->level_count - range->baseMipLevel
: range->levelCount;
}
uint32_t tu6_plane_count(VkFormat format);
enum pipe_format tu6_plane_format(VkFormat format, uint32_t plane);
@ -2376,7 +2349,7 @@ VK_DEFINE_NONDISP_HANDLE_CASTS(tu_device_memory, base, VkDeviceMemory,
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_event, base, VkEvent, VK_OBJECT_TYPE_EVENT)
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_framebuffer, base, VkFramebuffer,
VK_OBJECT_TYPE_FRAMEBUFFER)
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_image, base, VkImage, VK_OBJECT_TYPE_IMAGE)
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE)
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_image_view, base, VkImageView,
VK_OBJECT_TYPE_IMAGE_VIEW);
VK_DEFINE_NONDISP_HANDLE_CASTS(tu_pipeline_cache, base, VkPipelineCache,