anv,vulkan: Move VkImageSubresource* helpers from ANV

Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/12023>

diff --git a/src/intel/vulkan/anv_blorp.c b/src/intel/vulkan/anv_blorp.c
index ea5cdd3..765df4c 100644 (file)
--- a/src/intel/vulkan/anv_blorp.c
+++ b/src/intel/vulkan/anv_blorp.c
@@ -317,8 +317,8 @@ copy_image(struct anv_cmd_buffer *cmd_buffer,
       layer_count = region->extent.depth;
    } else {
       dst_base_layer = region->dstSubresource.baseArrayLayer;
-      layer_count =
-         anv_get_layerCount(dst_image, &region->dstSubresource);
+      layer_count = vk_image_subresource_layer_count(&dst_image->vk,
+                                                     &region->dstSubresource);
    }
 
    const uint32_t src_level = region->srcSubresource.mipLevel;
@@ -328,7 +328,8 @@ copy_image(struct anv_cmd_buffer *cmd_buffer,
    } else {
       src_base_layer = region->srcSubresource.baseArrayLayer;
       assert(layer_count ==
-             anv_get_layerCount(src_image, &region->srcSubresource));
+             vk_image_subresource_layer_count(&src_image->vk,
+                                              &region->srcSubresource));
    }
 
    VkImageAspectFlags src_mask = region->srcSubresource.aspectMask,
@@ -494,7 +495,9 @@ copy_buffer_to_image(struct anv_cmd_buffer *cmd_buffer,
       anv_sanitize_image_extent(anv_image->vk.image_type, region->imageExtent);
    if (anv_image->vk.image_type != VK_IMAGE_TYPE_3D) {
       image.offset.z = region->imageSubresource.baseArrayLayer;
-      extent.depth = anv_get_layerCount(anv_image, &region->imageSubresource);
+      extent.depth =
+         vk_image_subresource_layer_count(&anv_image->vk,
+                                          &region->imageSubresource);
    }
 
    const enum isl_format linear_format =
@@ -701,7 +704,8 @@ blit_image(struct anv_cmd_buffer *cmd_buffer,
          dst_end = region->dstOffsets[1].z;
       } else {
          dst_start = dst_res->baseArrayLayer;
-         dst_end = dst_start + anv_get_layerCount(dst_image, dst_res);
+         dst_end = dst_start +
+            vk_image_subresource_layer_count(&dst_image->vk, dst_res);
       }
 
       unsigned src_start, src_end;
@@ -711,7 +715,8 @@ blit_image(struct anv_cmd_buffer *cmd_buffer,
          src_end = region->srcOffsets[1].z;
       } else {
          src_start = src_res->baseArrayLayer;
-         src_end = src_start + anv_get_layerCount(src_image, src_res);
+         src_end = src_start +
+            vk_image_subresource_layer_count(&src_image->vk, src_res);
       }
 
       bool flip_z = flip_coords(&src_start, &src_end, &dst_start, &dst_end);
@@ -1034,9 +1039,12 @@ void anv_CmdClearColorImage(
                                VK_IMAGE_ASPECT_COLOR_BIT, image->vk.tiling);
 
       unsigned base_layer = pRanges[r].baseArrayLayer;
-      unsigned layer_count = anv_get_layerCount(image, &pRanges[r]);
+      uint32_t layer_count =
+         vk_image_subresource_layer_count(&image->vk, &pRanges[r]);
+      uint32_t level_count =
+         vk_image_subresource_level_count(&image->vk, &pRanges[r]);
 
-      for (unsigned i = 0; i < anv_get_levelCount(image, &pRanges[r]); i++) {
+      for (uint32_t i = 0; i < level_count; i++) {
          const unsigned level = pRanges[r].baseMipLevel + i;
          const unsigned level_width = anv_minify(image->vk.extent.width, level);
          const unsigned level_height = anv_minify(image->vk.extent.height, level);
@@ -1109,9 +1117,12 @@ void anv_CmdClearDepthStencilImage(
       bool clear_stencil = pRanges[r].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT;
 
       unsigned base_layer = pRanges[r].baseArrayLayer;
-      unsigned layer_count = anv_get_layerCount(image, &pRanges[r]);
+      uint32_t layer_count =
+         vk_image_subresource_layer_count(&image->vk, &pRanges[r]);
+      uint32_t level_count =
+         vk_image_subresource_level_count(&image->vk, &pRanges[r]);
 
-      for (unsigned i = 0; i < anv_get_levelCount(image, &pRanges[r]); i++) {
+      for (uint32_t i = 0; i < level_count; i++) {
          const unsigned level = pRanges[r].baseMipLevel + i;
          const unsigned level_width = anv_minify(image->vk.extent.width, level);
          const unsigned level_height = anv_minify(image->vk.extent.height, level);
@@ -1444,11 +1455,11 @@ resolve_image(struct anv_cmd_buffer *cmd_buffer,
               const VkImageResolve2KHR *region)
 {
    assert(region->srcSubresource.aspectMask == region->dstSubresource.aspectMask);
-   assert(anv_get_layerCount(src_image, &region->srcSubresource) ==
-          anv_get_layerCount(dst_image, &region->dstSubresource));
+   assert(vk_image_subresource_layer_count(&src_image->vk, &region->srcSubresource) ==
+          vk_image_subresource_layer_count(&dst_image->vk, &region->dstSubresource));
 
    const uint32_t layer_count =
-      anv_get_layerCount(dst_image, &region->dstSubresource);
+      vk_image_subresource_layer_count(&dst_image->vk, &region->dstSubresource);
 
    anv_foreach_image_aspect_bit(aspect_bit, src_image,
                                 region->srcSubresource.aspectMask) {

diff --git a/src/intel/vulkan/anv_image.c b/src/intel/vulkan/anv_image.c
index 7bd4bec..6e2ef8b 100644 (file)
--- a/src/intel/vulkan/anv_image.c
+++ b/src/intel/vulkan/anv_image.c
@@ -2675,16 +2675,17 @@ anv_CreateImageView(VkDevice _device,
                         VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
                         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT));
 
+   uint32_t layer_count = vk_image_subresource_layer_count(&image->vk, range);
    switch (image->vk.image_type) {
    default:
       unreachable("bad VkImageType");
    case VK_IMAGE_TYPE_1D:
    case VK_IMAGE_TYPE_2D:
-      assert(range->baseArrayLayer + anv_get_layerCount(image, range) - 1 <=
-             image->vk.array_layers);
+      assert(range->baseArrayLayer + layer_count - 1
+             <= image->vk.array_layers);
       break;
    case VK_IMAGE_TYPE_3D:
-      assert(range->baseArrayLayer + anv_get_layerCount(image, range) - 1
+      assert(range->baseArrayLayer + layer_count - 1
              <= anv_minify(image->vk.extent.depth, range->baseMipLevel));
       break;
    }
@@ -2760,9 +2761,9 @@ anv_CreateImageView(VkDevice _device,
       iview->planes[vplane].isl = (struct isl_view) {
          .format = format.isl_format,
          .base_level = range->baseMipLevel,
-         .levels = anv_get_levelCount(image, range),
+         .levels = vk_image_subresource_level_count(&image->vk, range),
          .base_array_layer = range->baseArrayLayer,
-         .array_len = anv_get_layerCount(image, range),
+         .array_len = layer_count,
          .swizzle = {
             .r = remap_swizzle(pCreateInfo->components.r,
                                VK_COMPONENT_SWIZZLE_R, format.swizzle),

diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h
index fd4a6f8..9da83af 100644 (file)
--- a/src/intel/vulkan/anv_private.h
+++ b/src/intel/vulkan/anv_private.h
@@ -4331,21 +4331,6 @@ anv_layout_to_fast_clear_type(const struct intel_device_info * const devinfo,
                               const VkImageAspectFlagBits aspect,
                               const VkImageLayout layout);
 
-/* This is defined as a macro so that it works for both
- * VkImageSubresourceRange and VkImageSubresourceLayers
- */
-#define anv_get_layerCount(_image, _range) \
-   ((_range)->layerCount == VK_REMAINING_ARRAY_LAYERS ? \
-    (_image)->vk.array_layers - (_range)->baseArrayLayer : (_range)->layerCount)
-
-static inline uint32_t
-anv_get_levelCount(const struct anv_image *image,
-                   const VkImageSubresourceRange *range)
-{
-   return range->levelCount == VK_REMAINING_MIP_LEVELS ?
-          image->vk.mip_levels - range->baseMipLevel : range->levelCount;
-}
-
 static inline bool
 anv_image_aspects_compatible(VkImageAspectFlags aspects1,
                              VkImageAspectFlags aspects2)

diff --git a/src/intel/vulkan/genX_cmd_buffer.c b/src/intel/vulkan/genX_cmd_buffer.c
index 58893c3..b177fff 100644 (file)
--- a/src/intel/vulkan/genX_cmd_buffer.c
+++ b/src/intel/vulkan/genX_cmd_buffer.c
@@ -2436,8 +2436,10 @@ void genX(CmdPipelineBarrier)(
          layer_count = anv_minify(image->vk.extent.depth, range->baseMipLevel);
       } else {
          base_layer = range->baseArrayLayer;
-         layer_count = anv_get_layerCount(image, range);
+         layer_count = vk_image_subresource_layer_count(&image->vk, range);
       }
+      const uint32_t level_count =
+         vk_image_subresource_level_count(&image->vk, range);
 
       if (range->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
          transition_depth_buffer(cmd_buffer, image,
@@ -2449,8 +2451,7 @@ void genX(CmdPipelineBarrier)(
 
       if (range->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
          transition_stencil_buffer(cmd_buffer, image,
-                                   range->baseMipLevel,
-                                   anv_get_levelCount(image, range),
+                                   range->baseMipLevel, level_count,
                                    base_layer, layer_count,
                                    pImageMemoryBarriers[i].oldLayout,
                                    pImageMemoryBarriers[i].newLayout,
@@ -2462,8 +2463,7 @@ void genX(CmdPipelineBarrier)(
             vk_image_expand_aspect_mask(&image->vk, range->aspectMask);
          anv_foreach_image_aspect_bit(aspect_bit, image, color_aspects) {
             transition_color_buffer(cmd_buffer, image, 1UL << aspect_bit,
-                                    range->baseMipLevel,
-                                    anv_get_levelCount(image, range),
+                                    range->baseMipLevel, level_count,
                                     base_layer, layer_count,
                                     pImageMemoryBarriers[i].oldLayout,
                                     pImageMemoryBarriers[i].newLayout,

diff --git a/src/vulkan/util/vk_image.h b/src/vulkan/util/vk_image.h
index c35b99b..ff8c352 100644 (file)
--- a/src/vulkan/util/vk_image.h
+++ b/src/vulkan/util/vk_image.h
@@ -92,6 +92,21 @@ vk_image_mip_level_extent(const struct vk_image *image,
    return extent;
 }
 
+/* This is defined as a macro so that it works for both
+ * VkImageSubresourceRange and VkImageSubresourceLayers
+ */
+#define vk_image_subresource_layer_count(_image, _range) \
+   ((_range)->layerCount == VK_REMAINING_ARRAY_LAYERS ? \
+    (_image)->array_layers - (_range)->baseArrayLayer : (_range)->layerCount)
+
+static inline uint32_t
+vk_image_subresource_level_count(const struct vk_image *image,
+                                 const VkImageSubresourceRange *range)
+{
+   return range->levelCount == VK_REMAINING_MIP_LEVELS ?
+          image->mip_levels - range->baseMipLevel : range->levelCount;
+}
+
 #ifdef __cplusplus
 }
 #endif