radv: add support for CmdResolveImage2KHR()

Signed-off-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6813>

4 files changed, 302 insertions, 251 deletions

diff --git a/src/amd/vulkan/radv_meta.h b/src/amd/vulkan/radv_meta.h
index f79946704b2..aaf569c0fe3 100644
--- a/src/amd/vulkan/radv_meta.h
+++ b/src/amd/vulkan/radv_meta.h
@@ -219,24 +219,21 @@ void radv_meta_resolve_compute_image(struct radv_cmd_buffer *cmd_buffer,
 				     struct radv_image *dest_image,
 				     VkFormat dest_format,
 				     VkImageLayout dest_image_layout,
-				     uint32_t region_count,
-				     const VkImageResolve *regions);
+				     const VkImageResolve2KHR *region);
 
 void radv_meta_resolve_fragment_image(struct radv_cmd_buffer *cmd_buffer,
 				      struct radv_image *src_image,
 				      VkImageLayout src_image_layout,
 				      struct radv_image *dest_image,
 				      VkImageLayout dest_image_layout,
-				      uint32_t region_count,
-				      const VkImageResolve *regions);
+				     const VkImageResolve2KHR *region);
 
 void radv_decompress_resolve_subpass_src(struct radv_cmd_buffer *cmd_buffer);
 
 void radv_decompress_resolve_src(struct radv_cmd_buffer *cmd_buffer,
 				 struct radv_image *src_image,
 				 VkImageLayout src_image_layout,
-				 uint32_t region_count,
-				 const VkImageResolve *regions);
+				 const VkImageResolve2KHR *region);
 
 uint32_t radv_clear_cmask(struct radv_cmd_buffer *cmd_buffer,
 			  struct radv_image *image,
diff --git a/src/amd/vulkan/radv_meta_resolve.c b/src/amd/vulkan/radv_meta_resolve.c
index 9d5a306c1cc..1318ff1c1e7 100644
--- a/src/amd/vulkan/radv_meta_resolve.c
+++ b/src/amd/vulkan/radv_meta_resolve.c
@@ -426,7 +426,7 @@ radv_meta_resolve_hardware_image(struct radv_cmd_buffer *cmd_buffer,
 				 VkImageLayout src_image_layout,
 				 struct radv_image *dst_image,
 				 VkImageLayout dst_image_layout,
-				 const VkImageResolve *region)
+				 const VkImageResolve2KHR *region)
 {
 	struct radv_device *device = cmd_buffer->device;
 	struct radv_meta_saved_state saved_state;
@@ -599,6 +599,47 @@ radv_meta_resolve_hardware_image(struct radv_cmd_buffer *cmd_buffer,
 	radv_meta_restore(&saved_state, cmd_buffer);
 }
 
+static void
+resolve_image(struct radv_cmd_buffer *cmd_buffer,
+	      struct radv_image *src_image,
+	      VkImageLayout src_image_layout,
+	      struct radv_image *dst_image,
+	      VkImageLayout dst_image_layout,
+	      const VkImageResolve2KHR *region,
+	      enum radv_resolve_method resolve_method)
+{
+	switch (resolve_method) {
+	case RESOLVE_HW:
+		radv_meta_resolve_hardware_image(cmd_buffer,
+						 src_image,
+						 src_image_layout,
+						 dst_image,
+						 dst_image_layout,
+						 region);
+		break;
+	case RESOLVE_FRAGMENT:
+		radv_meta_resolve_fragment_image(cmd_buffer,
+						 src_image,
+						 src_image_layout,
+						 dst_image,
+						 dst_image_layout,
+						 region);
+		break;
+	case RESOLVE_COMPUTE:
+		radv_meta_resolve_compute_image(cmd_buffer,
+						src_image,
+						src_image->vk_format,
+						src_image_layout,
+						dst_image,
+						dst_image->vk_format,
+						dst_image_layout,
+						region);
+		break;
+	default:
+		assert(!"Invalid resolve method selected");
+	}
+}
+
 void radv_CmdResolveImage(
 	VkCommandBuffer                             cmd_buffer_h,
 	VkImage                                     src_image_h,
@@ -635,36 +676,59 @@ void radv_CmdResolveImage(
 					dest_image_layout, false, cmd_buffer,
 					&resolve_method);
 
-	switch (resolve_method) {
-	case RESOLVE_HW:
-		assert(region_count == 1);
-		radv_meta_resolve_hardware_image(cmd_buffer,
-						 src_image,
-						 src_image_layout,
-						 dest_image,
-						 dest_image_layout,
-						 &regions[0]);
-		break;
-	case RESOLVE_FRAGMENT:
-		radv_meta_resolve_fragment_image(cmd_buffer,
-						 src_image,
-						 src_image_layout,
-						 dest_image,
-						 dest_image_layout,
-						 region_count, regions);
-		break;
-	case RESOLVE_COMPUTE:
-		radv_meta_resolve_compute_image(cmd_buffer,
-						src_image,
-						src_image->vk_format,
-						src_image_layout,
-						dest_image,
-						dest_image->vk_format,
-						dest_image_layout,
-						region_count, regions);
-		break;
-	default:
-		assert(!"Invalid resolve method selected");
+	for (uint32_t r = 0; r < region_count; r++) {
+		VkImageResolve2KHR region = {
+			.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
+			.srcSubresource = regions[r].srcSubresource,
+			.srcOffset      = regions[r].srcOffset,
+			.dstSubresource = regions[r].dstSubresource,
+			.dstOffset      = regions[r].dstOffset,
+			.extent         = regions[r].extent,
+		};
+
+		resolve_image(cmd_buffer, src_image, src_image_layout,
+			      dest_image, dest_image_layout,
+			      &region, resolve_method);
+	}
+}
+
+void radv_CmdResolveImage2KHR(
+	VkCommandBuffer                             commandBuffer,
+	const VkResolveImageInfo2KHR*               pResolveImageInfo)
+{
+	RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer);
+	RADV_FROM_HANDLE(radv_image, src_image, pResolveImageInfo->srcImage);
+	RADV_FROM_HANDLE(radv_image, dst_image, pResolveImageInfo->dstImage);
+	VkImageLayout src_image_layout = pResolveImageInfo->srcImageLayout;
+	VkImageLayout dst_image_layout = pResolveImageInfo->dstImageLayout;
+	enum radv_resolve_method resolve_method = RESOLVE_HW;
+	/* we can use the hw resolve only for single full resolves */
+	if (pResolveImageInfo->regionCount == 1) {
+		if (pResolveImageInfo->pRegions[0].srcOffset.x ||
+		    pResolveImageInfo->pRegions[0].srcOffset.y ||
+		    pResolveImageInfo->pRegions[0].srcOffset.z)
+			resolve_method = RESOLVE_COMPUTE;
+		if (pResolveImageInfo->pRegions[0].dstOffset.x ||
+		    pResolveImageInfo->pRegions[0].dstOffset.y ||
+		    pResolveImageInfo->pRegions[0].dstOffset.z)
+			resolve_method = RESOLVE_COMPUTE;
+
+		if (pResolveImageInfo->pRegions[0].extent.width != src_image->info.width ||
+		    pResolveImageInfo->pRegions[0].extent.height != src_image->info.height ||
+		    pResolveImageInfo->pRegions[0].extent.depth != src_image->info.depth)
+			resolve_method = RESOLVE_COMPUTE;
+	} else
+		resolve_method = RESOLVE_COMPUTE;
+
+	radv_pick_resolve_method_images(cmd_buffer->device, src_image,
+					src_image->vk_format, dst_image,
+					dst_image_layout, false, cmd_buffer,
+					&resolve_method);
+
+	for (uint32_t r = 0; r < pResolveImageInfo->regionCount; r++) {
+		resolve_image(cmd_buffer, src_image, src_image_layout,
+			      dst_image, dst_image_layout,
+			      &pResolveImageInfo->pRegions[r], resolve_method);
 	}
 }
 
@@ -839,14 +903,15 @@ radv_decompress_resolve_subpass_src(struct radv_cmd_buffer *cmd_buffer)
 		struct radv_image_view *src_iview = cmd_buffer->state.attachments[src_att.attachment].iview;
 		struct radv_image *src_image = src_iview->image;
 
-		VkImageResolve region = {};
+		VkImageResolve2KHR region = {};
+		region.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR;
 		region.srcSubresource.aspectMask = src_iview->aspect_mask;
 		region.srcSubresource.mipLevel = 0;
 		region.srcSubresource.baseArrayLayer = src_iview->base_layer;
 		region.srcSubresource.layerCount = layer_count;
 
 		radv_decompress_resolve_src(cmd_buffer, src_image,
-					    src_att.layout, 1, &region);
+					    src_att.layout, &region);
 	}
 
 	if (subpass->ds_resolve_attachment) {
@@ -854,14 +919,15 @@ radv_decompress_resolve_subpass_src(struct radv_cmd_buffer *cmd_buffer)
 		struct radv_image_view *src_iview = fb->attachments[src_att.attachment];
 		struct radv_image *src_image = src_iview->image;
 
-		VkImageResolve region = {};
+		VkImageResolve2KHR region = {};
+		region.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR;
 		region.srcSubresource.aspectMask = src_iview->aspect_mask;
 		region.srcSubresource.mipLevel = 0;
 		region.srcSubresource.baseArrayLayer = src_iview->base_layer;
 		region.srcSubresource.layerCount = layer_count;
 
 		radv_decompress_resolve_src(cmd_buffer, src_image,
-					    src_att.layout, 1, &region);
+					    src_att.layout, &region);
 	}
 }
 
@@ -886,48 +952,44 @@ void
 radv_decompress_resolve_src(struct radv_cmd_buffer *cmd_buffer,
 			    struct radv_image *src_image,
 			    VkImageLayout src_image_layout,
-			    uint32_t region_count,
-			    const VkImageResolve *regions)
+			     const VkImageResolve2KHR *region)
 {
-	for (uint32_t r = 0; r < region_count; ++r) {
-		const VkImageResolve *region = &regions[r];
-		const uint32_t src_base_layer =
-			radv_meta_get_iview_layer(src_image, &region->srcSubresource,
-						  &region->srcOffset);
-
-		VkImageMemoryBarrier barrier = {};
-		barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-		barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-		barrier.oldLayout = src_image_layout;
-		barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-		barrier.image = radv_image_to_handle(src_image);
-		barrier.subresourceRange = (VkImageSubresourceRange) {
-			.aspectMask = region->srcSubresource.aspectMask,
-			.baseMipLevel = region->srcSubresource.mipLevel,
-			.levelCount = 1,
-			.baseArrayLayer = src_base_layer,
-			.layerCount = region->srcSubresource.layerCount,
-		};
+	const uint32_t src_base_layer =
+		radv_meta_get_iview_layer(src_image, &region->srcSubresource,
+					  &region->srcOffset);
 
-		if (src_image->flags & VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT) {
-			/* If the depth/stencil image uses different sample
-			 * locations, we need them during HTILE decompressions.
-			 */
-			struct radv_sample_locations_state *sample_locs =
-				radv_get_resolve_sample_locations(cmd_buffer);
-
-			barrier.pNext = &(VkSampleLocationsInfoEXT) {
-				.sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
-				.sampleLocationsPerPixel = sample_locs->per_pixel,
-				.sampleLocationGridSize = sample_locs->grid_size,
-				.sampleLocationsCount = sample_locs->count,
-				.pSampleLocations = sample_locs->locations,
-			};
-		}
+	VkImageMemoryBarrier barrier = {};
+	barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+	barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+	barrier.oldLayout = src_image_layout;
+	barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+	barrier.image = radv_image_to_handle(src_image);
+	barrier.subresourceRange = (VkImageSubresourceRange) {
+		.aspectMask = region->srcSubresource.aspectMask,
+		.baseMipLevel = region->srcSubresource.mipLevel,
+		.levelCount = 1,
+		.baseArrayLayer = src_base_layer,
+		.layerCount = region->srcSubresource.layerCount,
+	};
 
-		radv_CmdPipelineBarrier(radv_cmd_buffer_to_handle(cmd_buffer),
-					VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-					VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-					false, 0, NULL, 0, NULL, 1, &barrier);
+	if (src_image->flags & VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT) {
+		/* If the depth/stencil image uses different sample
+		 * locations, we need them during HTILE decompressions.
+		 */
+		struct radv_sample_locations_state *sample_locs =
+			radv_get_resolve_sample_locations(cmd_buffer);
+
+		barrier.pNext = &(VkSampleLocationsInfoEXT) {
+			.sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
+			.sampleLocationsPerPixel = sample_locs->per_pixel,
+			.sampleLocationGridSize = sample_locs->grid_size,
+			.sampleLocationsCount = sample_locs->count,
+			.pSampleLocations = sample_locs->locations,
+		};
 	}
+
+	radv_CmdPipelineBarrier(radv_cmd_buffer_to_handle(cmd_buffer),
+				VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+				VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+				false, 0, NULL, 0, NULL, 1, &barrier);
 }
diff --git a/src/amd/vulkan/radv_meta_resolve_cs.c b/src/amd/vulkan/radv_meta_resolve_cs.c
index e1e30777062..a5b5c322c7e 100644
--- a/src/amd/vulkan/radv_meta_resolve_cs.c
+++ b/src/amd/vulkan/radv_meta_resolve_cs.c
@@ -811,84 +811,80 @@ void radv_meta_resolve_compute_image(struct radv_cmd_buffer *cmd_buffer,
 				     struct radv_image *dest_image,
 				     VkFormat dest_format,
 				     VkImageLayout dest_image_layout,
-				     uint32_t region_count,
-				     const VkImageResolve *regions)
+				     const VkImageResolve2KHR *region)
 {
 	struct radv_meta_saved_state saved_state;
 
 	radv_decompress_resolve_src(cmd_buffer, src_image, src_image_layout,
-				    region_count, regions);
+				    region);
 
 	radv_meta_save(&saved_state, cmd_buffer,
 		       RADV_META_SAVE_COMPUTE_PIPELINE |
 		       RADV_META_SAVE_CONSTANTS |
 		       RADV_META_SAVE_DESCRIPTORS);
 
-	for (uint32_t r = 0; r < region_count; ++r) {
-		const VkImageResolve *region = &regions[r];
-
-		assert(region->srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
-		assert(region->dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
-		assert(region->srcSubresource.layerCount == region->dstSubresource.layerCount);
-
-		const uint32_t src_base_layer =
-			radv_meta_get_iview_layer(src_image, &region->srcSubresource,
-						  &region->srcOffset);
-
-		const uint32_t dest_base_layer =
-			radv_meta_get_iview_layer(dest_image, &region->dstSubresource,
-						  &region->dstOffset);
-
-		const struct VkExtent3D extent =
-			radv_sanitize_image_extent(src_image->type, region->extent);
-		const struct VkOffset3D srcOffset =
-			radv_sanitize_image_offset(src_image->type, region->srcOffset);
-		const struct VkOffset3D dstOffset =
-			radv_sanitize_image_offset(dest_image->type, region->dstOffset);
-
-		for (uint32_t layer = 0; layer < region->srcSubresource.layerCount;
-		     ++layer) {
-
-			struct radv_image_view src_iview;
-			radv_image_view_init(&src_iview, cmd_buffer->device,
-					     &(VkImageViewCreateInfo) {
-						     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-							     .image = radv_image_to_handle(src_image),
-							     .viewType = radv_meta_get_view_type(src_image),
-							     .format = src_format,
-							     .subresourceRange = {
-							     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-							     .baseMipLevel = region->srcSubresource.mipLevel,
-							     .levelCount = 1,
-							     .baseArrayLayer = src_base_layer + layer,
-							     .layerCount = 1,
-						     },
-					     }, NULL);
-
-			struct radv_image_view dest_iview;
-			radv_image_view_init(&dest_iview, cmd_buffer->device,
-					     &(VkImageViewCreateInfo) {
-						     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-							     .image = radv_image_to_handle(dest_image),
-							     .viewType = radv_meta_get_view_type(dest_image),
-							     .format = vk_to_non_srgb_format(dest_format),
-							     .subresourceRange = {
-							     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-							     .baseMipLevel = region->dstSubresource.mipLevel,
-							     .levelCount = 1,
-							     .baseArrayLayer = dest_base_layer + layer,
-							     .layerCount = 1,
-						     },
-					     }, NULL);
-
-			emit_resolve(cmd_buffer,
-				     &src_iview,
-				     &dest_iview,
-				     &(VkOffset2D) {srcOffset.x, srcOffset.y },
-				     &(VkOffset2D) {dstOffset.x, dstOffset.y },
-				     &(VkExtent2D) {extent.width, extent.height });
-		}
+	assert(region->srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
+	assert(region->dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
+	assert(region->srcSubresource.layerCount == region->dstSubresource.layerCount);
+
+	const uint32_t src_base_layer =
+		radv_meta_get_iview_layer(src_image, &region->srcSubresource,
+					  &region->srcOffset);
+
+	const uint32_t dest_base_layer =
+		radv_meta_get_iview_layer(dest_image, &region->dstSubresource,
+					  &region->dstOffset);
+
+	const struct VkExtent3D extent =
+		radv_sanitize_image_extent(src_image->type, region->extent);
+	const struct VkOffset3D srcOffset =
+		radv_sanitize_image_offset(src_image->type, region->srcOffset);
+	const struct VkOffset3D dstOffset =
+		radv_sanitize_image_offset(dest_image->type, region->dstOffset);
+
+	for (uint32_t layer = 0; layer < region->srcSubresource.layerCount;
+	     ++layer) {
+
+		struct radv_image_view src_iview;
+		radv_image_view_init(&src_iview, cmd_buffer->device,
+				     &(VkImageViewCreateInfo) {
+					     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+						     .image = radv_image_to_handle(src_image),
+						     .viewType = radv_meta_get_view_type(src_image),
+						     .format = src_format,
+						     .subresourceRange = {
+						     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+						     .baseMipLevel = region->srcSubresource.mipLevel,
+						     .levelCount = 1,
+						     .baseArrayLayer = src_base_layer + layer,
+						     .layerCount = 1,
+					     },
+				     }, NULL);
+
+		struct radv_image_view dest_iview;
+		radv_image_view_init(&dest_iview, cmd_buffer->device,
+				     &(VkImageViewCreateInfo) {
+					     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+						     .image = radv_image_to_handle(dest_image),
+						     .viewType = radv_meta_get_view_type(dest_image),
+						     .format = vk_to_non_srgb_format(dest_format),
+						     .subresourceRange = {
+						     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+						     .baseMipLevel = region->dstSubresource.mipLevel,
+						     .levelCount = 1,
+						     .baseArrayLayer = dest_base_layer + layer,
+						     .layerCount = 1,
+					     },
+				     }, NULL);
+
+		emit_resolve(cmd_buffer,
+			     &src_iview,
+			     &dest_iview,
+			     &(VkOffset2D) {srcOffset.x, srcOffset.y },
+			     &(VkOffset2D) {dstOffset.x, dstOffset.y },
+			     &(VkExtent2D) {extent.width, extent.height });
 	}
+
 	radv_meta_restore(&saved_state, cmd_buffer);
 }
 
@@ -924,7 +920,8 @@ radv_cmd_buffer_resolve_subpass_cs(struct radv_cmd_buffer *cmd_buffer)
 		struct radv_image_view *src_iview = cmd_buffer->state.attachments[src_att.attachment].iview;
 		struct radv_image_view *dst_iview = cmd_buffer->state.attachments[dst_att.attachment].iview;
 
-		VkImageResolve region = {
+		VkImageResolve2KHR region = {
+			.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
 			.extent = (VkExtent3D){ fb->width, fb->height, 0 },
 			.srcSubresource = (VkImageSubresourceLayers) {
 				.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -949,7 +946,7 @@ radv_cmd_buffer_resolve_subpass_cs(struct radv_cmd_buffer *cmd_buffer)
 						dst_iview->image,
 						dst_iview->vk_format,
 						dst_att.layout,
-						1, &region);
+						&region);
 	}
 
 	cmd_buffer->state.flush_bits |= RADV_CMD_FLAG_CS_PARTIAL_FLUSH |
diff --git a/src/amd/vulkan/radv_meta_resolve_fs.c b/src/amd/vulkan/radv_meta_resolve_fs.c
index 12ff91ab3f3..c60d5eb1dca 100644
--- a/src/amd/vulkan/radv_meta_resolve_fs.c
+++ b/src/amd/vulkan/radv_meta_resolve_fs.c
@@ -1027,8 +1027,7 @@ void radv_meta_resolve_fragment_image(struct radv_cmd_buffer *cmd_buffer,
 				      VkImageLayout src_image_layout,
 				      struct radv_image *dest_image,
 				      VkImageLayout dest_image_layout,
-				      uint32_t region_count,
-				      const VkImageResolve *regions)
+				      const VkImageResolve2KHR *region)
 {
 	struct radv_device *device = cmd_buffer->device;
 	struct radv_meta_saved_state saved_state;
@@ -1039,7 +1038,7 @@ void radv_meta_resolve_fragment_image(struct radv_cmd_buffer *cmd_buffer,
 	VkRenderPass rp;
 
 	radv_decompress_resolve_src(cmd_buffer, src_image, src_image_layout,
-				    region_count, regions);
+				    region);
 
 	if (!device->meta_state.resolve_fragment.rc[samples_log2].render_pass[fs_key][dst_layout]) {
 		VkResult ret = create_resolve_pipeline(device, samples_log2, radv_fs_key_format_exemplars[fs_key]);
@@ -1056,104 +1055,100 @@ void radv_meta_resolve_fragment_image(struct radv_cmd_buffer *cmd_buffer,
 		       RADV_META_SAVE_CONSTANTS |
 		       RADV_META_SAVE_DESCRIPTORS);
 
-	for (uint32_t r = 0; r < region_count; ++r) {
-		const VkImageResolve *region = &regions[r];
-
-		assert(region->srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
-		assert(region->dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
-		assert(region->srcSubresource.layerCount == region->dstSubresource.layerCount);
-
-		const uint32_t src_base_layer =
-			radv_meta_get_iview_layer(src_image, &region->srcSubresource,
-						  &region->srcOffset);
-
-		const uint32_t dest_base_layer =
-			radv_meta_get_iview_layer(dest_image, &region->dstSubresource,
-						  &region->dstOffset);
-
-		const struct VkExtent3D extent =
-			radv_sanitize_image_extent(src_image->type, region->extent);
-		const struct VkOffset3D srcOffset =
-			radv_sanitize_image_offset(src_image->type, region->srcOffset);
-		const struct VkOffset3D dstOffset =
-			radv_sanitize_image_offset(dest_image->type, region->dstOffset);
-
-		for (uint32_t layer = 0; layer < region->srcSubresource.layerCount;
-		     ++layer) {
-
-			struct radv_image_view src_iview;
-			radv_image_view_init(&src_iview, cmd_buffer->device,
-					     &(VkImageViewCreateInfo) {
-						     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-							     .image = radv_image_to_handle(src_image),
-							     .viewType = radv_meta_get_view_type(src_image),
-							     .format = src_image->vk_format,
-							     .subresourceRange = {
-							     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-							     .baseMipLevel = region->srcSubresource.mipLevel,
-							     .levelCount = 1,
-							     .baseArrayLayer = src_base_layer + layer,
-							     .layerCount = 1,
-						     },
-					     }, NULL);
-
-			struct radv_image_view dest_iview;
-			radv_image_view_init(&dest_iview, cmd_buffer->device,
-					     &(VkImageViewCreateInfo) {
-						     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-							     .image = radv_image_to_handle(dest_image),
-							     .viewType = radv_meta_get_view_type(dest_image),
-							     .format = dest_image->vk_format,
-							     .subresourceRange = {
-							     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-							     .baseMipLevel = region->dstSubresource.mipLevel,
-							     .levelCount = 1,
-							     .baseArrayLayer = dest_base_layer + layer,
-							     .layerCount = 1,
-						     },
-					     }, NULL);
-
-
-			VkFramebuffer fb;
-			radv_CreateFramebuffer(radv_device_to_handle(cmd_buffer->device),
-			       &(VkFramebufferCreateInfo) {
-				       .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-					       .attachmentCount = 1,
-					       .pAttachments = (VkImageView[]) {
-					       radv_image_view_to_handle(&dest_iview),
-				       },
-				       .width = extent.width + dstOffset.x,
-				       .height = extent.height + dstOffset.y,
-				       .layers = 1
-				}, &cmd_buffer->pool->alloc, &fb);
-
-			radv_cmd_buffer_begin_render_pass(cmd_buffer,
-							  &(VkRenderPassBeginInfo) {
-								.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-									.renderPass = rp,
-									.framebuffer = fb,
-									.renderArea = {
-										.offset = { dstOffset.x, dstOffset.y, },
-										.extent = { extent.width, extent.height },
-									},
-								.clearValueCount = 0,
-								.pClearValues = NULL,
-						});
-
-			radv_cmd_buffer_set_subpass(cmd_buffer,
-						    &cmd_buffer->state.pass->subpasses[0]);
-
-			emit_resolve(cmd_buffer,
-				     &src_iview,
-				     &dest_iview,
-				     &(VkOffset2D) { srcOffset.x, srcOffset.y },
-				     &(VkOffset2D) { dstOffset.x, dstOffset.y },
-				     &(VkExtent2D) { extent.width, extent.height });
-
-			radv_cmd_buffer_end_render_pass(cmd_buffer);
-
-			radv_DestroyFramebuffer(radv_device_to_handle(cmd_buffer->device), fb, &cmd_buffer->pool->alloc);
-		}
+	assert(region->srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
+	assert(region->dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
+	assert(region->srcSubresource.layerCount == region->dstSubresource.layerCount);
+
+	const uint32_t src_base_layer =
+		radv_meta_get_iview_layer(src_image, &region->srcSubresource,
+					  &region->srcOffset);
+
+	const uint32_t dest_base_layer =
+		radv_meta_get_iview_layer(dest_image, &region->dstSubresource,
+					  &region->dstOffset);
+
+	const struct VkExtent3D extent =
+		radv_sanitize_image_extent(src_image->type, region->extent);
+	const struct VkOffset3D srcOffset =
+		radv_sanitize_image_offset(src_image->type, region->srcOffset);
+	const struct VkOffset3D dstOffset =
+		radv_sanitize_image_offset(dest_image->type, region->dstOffset);
+
+	for (uint32_t layer = 0; layer < region->srcSubresource.layerCount;
+	     ++layer) {
+
+		struct radv_image_view src_iview;
+		radv_image_view_init(&src_iview, cmd_buffer->device,
+				     &(VkImageViewCreateInfo) {
+					     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+						     .image = radv_image_to_handle(src_image),
+						     .viewType = radv_meta_get_view_type(src_image),
+						     .format = src_image->vk_format,
+						     .subresourceRange = {
+						     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+						     .baseMipLevel = region->srcSubresource.mipLevel,
+						     .levelCount = 1,
+						     .baseArrayLayer = src_base_layer + layer,
+						     .layerCount = 1,
+					     },
+				     }, NULL);
+
+		struct radv_image_view dest_iview;
+		radv_image_view_init(&dest_iview, cmd_buffer->device,
+				     &(VkImageViewCreateInfo) {
+					     .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+						     .image = radv_image_to_handle(dest_image),
+						     .viewType = radv_meta_get_view_type(dest_image),
+						     .format = dest_image->vk_format,
+						     .subresourceRange = {
+						     .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+						     .baseMipLevel = region->dstSubresource.mipLevel,
+						     .levelCount = 1,
+						     .baseArrayLayer = dest_base_layer + layer,
+						     .layerCount = 1,
+					     },
+				     }, NULL);
+
+
+		VkFramebuffer fb;
+		radv_CreateFramebuffer(radv_device_to_handle(cmd_buffer->device),
+		       &(VkFramebufferCreateInfo) {
+			       .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+				       .attachmentCount = 1,
+				       .pAttachments = (VkImageView[]) {
+				       radv_image_view_to_handle(&dest_iview),
+			       },
+			       .width = extent.width + dstOffset.x,
+			       .height = extent.height + dstOffset.y,
+			       .layers = 1
+			}, &cmd_buffer->pool->alloc, &fb);
+
+		radv_cmd_buffer_begin_render_pass(cmd_buffer,
+						  &(VkRenderPassBeginInfo) {
+							.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+								.renderPass = rp,
+								.framebuffer = fb,
+								.renderArea = {
+									.offset = { dstOffset.x, dstOffset.y, },
+									.extent = { extent.width, extent.height },
+								},
+							.clearValueCount = 0,
+							.pClearValues = NULL,
+					});
+
+		radv_cmd_buffer_set_subpass(cmd_buffer,
+					    &cmd_buffer->state.pass->subpasses[0]);
+
+		emit_resolve(cmd_buffer,
+			     &src_iview,
+			     &dest_iview,
+			     &(VkOffset2D) { srcOffset.x, srcOffset.y },
+			     &(VkOffset2D) { dstOffset.x, dstOffset.y },
+			     &(VkExtent2D) { extent.width, extent.height });
+
+		radv_cmd_buffer_end_render_pass(cmd_buffer);
+
+		radv_DestroyFramebuffer(radv_device_to_handle(cmd_buffer->device), fb, &cmd_buffer->pool->alloc);
 	}
 
 	radv_meta_restore(&saved_state, cmd_buffer);