anv/meta: Use blitter API for copies between Images and Buffers

Signed-off-by: Nanley Chery <[email protected]>
Reviewed-by: Jason Ekstrand <[email protected]>

1 files changed, 6 insertions, 208 deletions

diff --git a/src/intel/vulkan/anv_meta_blit.c b/src/intel/vulkan/anv_meta_blit.c
index 8cda3d587fa..8ca1871f9d8 100644
--- a/src/intel/vulkan/anv_meta_blit.c
+++ b/src/intel/vulkan/anv_meta_blit.c
@@ -1189,121 +1189,10 @@ void anv_CmdCopyBufferToImage(
 {
    ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer);
    ANV_FROM_HANDLE(anv_image, dest_image, destImage);
-   VkDevice vk_device = anv_device_to_handle(cmd_buffer->device);
-   struct anv_meta_saved_state saved_state;
-
-   /* The Vulkan 1.0 spec says "dstImage must have a sample count equal to
-    * VK_SAMPLE_COUNT_1_BIT."
-    */
-   assert(dest_image->samples == 1);
-
-   meta_prepare_blit(cmd_buffer, &saved_state);
-
-   for (unsigned r = 0; r < regionCount; r++) {
-      VkImageAspectFlags aspect = pRegions[r].imageSubresource.aspectMask;
-
-      VkFormat image_format = choose_iview_format(dest_image, aspect);
-
-      struct anv_image *src_image =
-         make_image_for_buffer(vk_device, srcBuffer, dest_image->vk_format,
-                               VK_IMAGE_USAGE_SAMPLED_BIT,
-                               dest_image->type, &cmd_buffer->pool->alloc,
-                               &pRegions[r]);
-
-      const uint32_t dest_base_array_slice =
-         anv_meta_get_iview_layer(dest_image, &pRegions[r].imageSubresource,
-                                  &pRegions[r].imageOffset);
-
-      unsigned num_slices_3d = pRegions[r].imageExtent.depth;
-      unsigned num_slices_array = pRegions[r].imageSubresource.layerCount;
-      unsigned slice_3d = 0;
-      unsigned slice_array = 0;
-      while (slice_3d < num_slices_3d && slice_array < num_slices_array) {
-         struct anv_image_view src_iview;
-         anv_image_view_init(&src_iview, cmd_buffer->device,
-            &(VkImageViewCreateInfo) {
-               .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-               .image = anv_image_to_handle(src_image),
-               .viewType = VK_IMAGE_VIEW_TYPE_2D,
-               .format = src_image->vk_format,
-               .subresourceRange = {
-                  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                  .baseMipLevel = 0,
-                  .levelCount = 1,
-                  .baseArrayLayer = 0,
-                  .layerCount = 1,
-               },
-            },
-            cmd_buffer, 0, VK_IMAGE_USAGE_SAMPLED_BIT);
-
-         uint32_t img_x = 0;
-         uint32_t img_y = 0;
-         uint32_t img_o = 0;
-         if (isl_format_is_compressed(dest_image->format->isl_format))
-            isl_surf_get_image_intratile_offset_el(&cmd_buffer->device->isl_dev,
-                                                   &dest_image->color_surface.isl,
-                                                   pRegions[r].imageSubresource.mipLevel,
-                                                   pRegions[r].imageSubresource.baseArrayLayer + slice_array,
-                                                   pRegions[r].imageOffset.z + slice_3d,
-                                                   &img_o, &img_x, &img_y);
-
-         VkOffset3D dest_offset_el = meta_region_offset_el(dest_image, & pRegions[r].imageOffset);
-         dest_offset_el.x += img_x;
-         dest_offset_el.y += img_y;
-         dest_offset_el.z = 0;
-
-         struct anv_image_view dest_iview;
-         anv_image_view_init(&dest_iview, cmd_buffer->device,
-            &(VkImageViewCreateInfo) {
-               .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-               .image = anv_image_to_handle(dest_image),
-               .viewType = anv_meta_get_view_type(dest_image),
-               .format = image_format,
-               .subresourceRange = {
-                  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                  .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
-                  .levelCount = 1,
-                  .baseArrayLayer = dest_base_array_slice +
-                                    slice_array + slice_3d,
-                  .layerCount = 1
-               },
-            },
-            cmd_buffer, img_o, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
-
-         const VkExtent3D img_extent_el = meta_region_extent_el(dest_image->vk_format,
-                                                      &pRegions[r].imageExtent);
-
-         meta_emit_blit(cmd_buffer,
-                        src_image,
-                        &src_iview,
-                        (VkOffset3D){0, 0, 0},
-                        img_extent_el,
-                        dest_image,
-                        &dest_iview,
-                        dest_offset_el,
-                        img_extent_el,
-                        VK_FILTER_NEAREST);
-
-         /* Once we've done the blit, all of the actual information about
-          * the image is embedded in the command buffer so we can just
-          * increment the offset directly in the image effectively
-          * re-binding it to different backing memory.
-          */
-         src_image->offset += src_image->extent.width *
-                              src_image->extent.height *
-                              src_image->format->isl_layout->bs;
-
-         if (dest_image->type == VK_IMAGE_TYPE_3D)
-            slice_3d++;
-         else
-            slice_array++;
-      }
-
-      anv_DestroyImage(vk_device, anv_image_to_handle(src_image),
-                       &cmd_buffer->pool->alloc);
-   }
+   ANV_FROM_HANDLE(anv_buffer, src_buffer, srcBuffer);
 
-   meta_finish_blit(cmd_buffer, &saved_state);
+   meta_copy_buffer_to_image(cmd_buffer, src_buffer, dest_image,
+                             regionCount, pRegions, true);
 }
 
 void anv_CmdCopyImageToBuffer(
@@ -1316,101 +1205,10 @@ void anv_CmdCopyImageToBuffer(
 {
    ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer);
    ANV_FROM_HANDLE(anv_image, src_image, srcImage);
-   VkDevice vk_device = anv_device_to_handle(cmd_buffer->device);
-   struct anv_meta_saved_state saved_state;
-
-
-   /* The Vulkan 1.0 spec says "srcImage must have a sample count equal to
-    * VK_SAMPLE_COUNT_1_BIT."
-    */
-   assert(src_image->samples == 1);
-
-   meta_prepare_blit(cmd_buffer, &saved_state);
-
-   for (unsigned r = 0; r < regionCount; r++) {
-      VkImageAspectFlags aspect = pRegions[r].imageSubresource.aspectMask;
-
-      VkFormat image_format = choose_iview_format(src_image, aspect);
-
-      struct anv_image_view src_iview;
-      anv_image_view_init(&src_iview, cmd_buffer->device,
-         &(VkImageViewCreateInfo) {
-            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-            .image = srcImage,
-            .viewType = anv_meta_get_view_type(src_image),
-            .format = image_format,
-            .subresourceRange = {
-               .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-               .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
-               .levelCount = 1,
-               .baseArrayLayer = pRegions[r].imageSubresource.baseArrayLayer,
-               .layerCount = pRegions[r].imageSubresource.layerCount,
-            },
-         },
-         cmd_buffer, 0, VK_IMAGE_USAGE_SAMPLED_BIT);
-
-      struct anv_image *dest_image =
-         make_image_for_buffer(vk_device, destBuffer, src_image->vk_format,
-                               VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-                               src_image->type, &cmd_buffer->pool->alloc,
-                               &pRegions[r]);
-
-      unsigned num_slices;
-      if (src_image->type == VK_IMAGE_TYPE_3D) {
-         assert(pRegions[r].imageSubresource.layerCount == 1);
-         num_slices = pRegions[r].imageExtent.depth;
-      } else {
-         assert(pRegions[r].imageExtent.depth == 1);
-         num_slices = pRegions[r].imageSubresource.layerCount;
-      }
-
-      for (unsigned slice = 0; slice < num_slices; slice++) {
-         VkOffset3D src_offset = pRegions[r].imageOffset;
-         src_offset.z += slice;
-
-         struct anv_image_view dest_iview;
-         anv_image_view_init(&dest_iview, cmd_buffer->device,
-            &(VkImageViewCreateInfo) {
-               .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-               .image = anv_image_to_handle(dest_image),
-               .viewType = VK_IMAGE_VIEW_TYPE_2D,
-               .format = dest_image->vk_format,
-               .subresourceRange = {
-                  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                  .baseMipLevel = 0,
-                  .levelCount = 1,
-                  .baseArrayLayer = 0,
-                  .layerCount = 1
-               },
-            },
-            cmd_buffer, 0, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+   ANV_FROM_HANDLE(anv_buffer, dst_buffer, destBuffer);
 
-         meta_emit_blit(cmd_buffer,
-                        anv_image_from_handle(srcImage),
-                        &src_iview,
-                        src_offset,
-                        pRegions[r].imageExtent,
-                        dest_image,
-                        &dest_iview,
-                        (VkOffset3D) { 0, 0, 0 },
-                        pRegions[r].imageExtent,
-                        VK_FILTER_NEAREST);
-
-         /* Once we've done the blit, all of the actual information about
-          * the image is embedded in the command buffer so we can just
-          * increment the offset directly in the image effectively
-          * re-binding it to different backing memory.
-          */
-         dest_image->offset += dest_image->extent.width *
-                               dest_image->extent.height *
-                               src_image->format->isl_layout->bs;
-      }
-
-      anv_DestroyImage(vk_device, anv_image_to_handle(dest_image),
-                       &cmd_buffer->pool->alloc);
-   }
-
-   meta_finish_blit(cmd_buffer, &saved_state);
+   meta_copy_buffer_to_image(cmd_buffer, dst_buffer, src_image,
+                             regionCount, pRegions, false);
 }
 
 void