From 2348eb41f38a6e52e52d121adfc4c605763209a7 Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Wed, 17 Nov 2021 15:04:38 -0500
Subject: video_core: Add S8_UINT stencil format

---
 src/video_core/texture_cache/formatter.h | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/formatter.h b/src/video_core/texture_cache/formatter.h
index c6cf0583f..b2c81057b 100644
--- a/src/video_core/texture_cache/formatter.h
+++ b/src/video_core/texture_cache/formatter.h
@@ -194,6 +194,8 @@ struct fmt::formatter<VideoCore::Surface::PixelFormat> : fmt::formatter<fmt::str
                 return "D32_FLOAT";
             case PixelFormat::D16_UNORM:
                 return "D16_UNORM";
+            case PixelFormat::S8_UINT:
+                return "S8_UINT";
             case PixelFormat::D24_UNORM_S8_UINT:
                 return "D24_UNORM_S8_UINT";
             case PixelFormat::S8_UINT_D24_UNORM:
-- 
cgit v1.2.3


From b130f648d7c629411c487722f864c6bafcd2562c Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 19 Nov 2021 03:17:54 +0100
Subject: TextureCache: Fix regression caused by ART and improve blit detection
 algorithm to be smarter.

---
 src/video_core/texture_cache/texture_cache.h |  9 +++------
 src/video_core/texture_cache/util.cpp        | 28 ++++++++++++++++++++++++----
 2 files changed, 27 insertions(+), 10 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 241f71a91..5ade3ce55 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -475,6 +475,7 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     const BlitImages images = GetBlitImages(dst, src);
     const ImageId dst_id = images.dst_id;
     const ImageId src_id = images.src_id;
+
     PrepareImage(src_id, false, false);
     PrepareImage(dst_id, true, false);
 
@@ -1094,12 +1095,8 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
         if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
             continue;
         }
-        if (!dst_id) {
-            dst_id = InsertImage(dst_info, dst_addr, RelaxedOptions{});
-        }
-        if (!src_id) {
-            src_id = InsertImage(src_info, src_addr, RelaxedOptions{});
-        }
+        src_id = FindOrInsertImage(src_info, src_addr);
+        dst_id = FindOrInsertImage(dst_info, dst_addr);
     } while (has_deleted_images);
     return BlitImages{
         .dst_id = dst_id,
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index ddc9fb13a..8f9eb387c 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1151,17 +1151,37 @@ bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src) {
-    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+    if (src) {
         src_info.format = src->info.format;
+        src_info.num_samples = src->info.num_samples;
+        src_info.size = src->info.size;
     }
-    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
+    if (dst) {
         dst_info.format = dst->info.format;
+        dst_info.num_samples = dst->info.num_samples;
+        dst_info.size = dst->info.size;
     }
     if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
-        dst_info.format = src->info.format;
+        if (dst) {
+            src_info.format = dst_info.format;
+        } else {
+            dst_info.format = src->info.format;
+        }
     }
     if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
-        src_info.format = dst->info.format;
+        if (src) {
+            if (GetFormatType(src->info.format) == SurfaceType::ColorTexture) {
+                dst_info.format = src->info.format;
+            }
+        } else {
+            src_info.format = dst->info.format;
+        }
+    }
+    if (src_info.num_samples > 1) {
+        dst_info.format = src_info.format;
+    }
+    if (dst_info.num_samples > 1) {
+        src_info.format = dst_info.format;
     }
 }
 
-- 
cgit v1.2.3


From 0ff228405faae92a39167b9aec072e14744eae35 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 19 Nov 2021 05:46:57 +0100
Subject: TextureCache: force same image format when resolving an image.

---
 src/video_core/texture_cache/texture_cache.h | 10 ++++++++--
 src/video_core/texture_cache/types.h         |  1 +
 2 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 5ade3ce55..06257f064 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -759,7 +759,8 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
             return ImageId{};
         }
     }
-    const bool broken_views = runtime.HasBrokenTextureViewFormats();
+    const bool broken_views =
+        runtime.HasBrokenTextureViewFormats() || True(options & RelaxedOptions::ForceBrokenViews);
     const bool native_bgr = runtime.HasNativeBgr();
     ImageId image_id;
     const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
@@ -1096,7 +1097,12 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
             continue;
         }
         src_id = FindOrInsertImage(src_info, src_addr);
-        dst_id = FindOrInsertImage(dst_info, dst_addr);
+        RelaxedOptions dst_options{};
+        if (src_info.num_samples > 1) {
+            // it's a resolve, we must enforce the same format.
+            dst_options = RelaxedOptions::ForceBrokenViews;
+        }
+        dst_id = FindOrInsertImage(dst_info, dst_addr, dst_options);
     } while (has_deleted_images);
     return BlitImages{
         .dst_id = dst_id,
diff --git a/src/video_core/texture_cache/types.h b/src/video_core/texture_cache/types.h
index 5c274abdf..5ac27b3a7 100644
--- a/src/video_core/texture_cache/types.h
+++ b/src/video_core/texture_cache/types.h
@@ -54,6 +54,7 @@ enum class RelaxedOptions : u32 {
     Size = 1 << 0,
     Format = 1 << 1,
     Samples = 1 << 2,
+    ForceBrokenViews = 1 << 3,
 };
 DECLARE_ENUM_FLAG_OPERATORS(RelaxedOptions)
 
-- 
cgit v1.2.3


From 6f896d1fae3d244f83450a485d15e7cebe79abaa Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 19 Nov 2021 22:23:48 +0100
Subject: TextureCache: Further fixes on resolve algorithm.

---
 src/video_core/texture_cache/texture_cache.h |  8 ++++----
 src/video_core/texture_cache/util.cpp        | 25 +++++++++++++------------
 2 files changed, 17 insertions(+), 16 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 06257f064..4188f93c5 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1096,13 +1096,13 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
         if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
             continue;
         }
-        src_id = FindOrInsertImage(src_info, src_addr);
-        RelaxedOptions dst_options{};
+        RelaxedOptions find_options{};
         if (src_info.num_samples > 1) {
             // it's a resolve, we must enforce the same format.
-            dst_options = RelaxedOptions::ForceBrokenViews;
+            find_options = RelaxedOptions::ForceBrokenViews;
         }
-        dst_id = FindOrInsertImage(dst_info, dst_addr, dst_options);
+        src_id = FindOrInsertImage(src_info, src_addr, find_options);
+        dst_id = FindOrInsertImage(dst_info, dst_addr, find_options);
     } while (has_deleted_images);
     return BlitImages{
         .dst_id = dst_id,
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index 8f9eb387c..e4d82631e 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1151,19 +1151,25 @@ bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src) {
+    bool is_resolve = false;
+    const auto original_src_format = src_info.format;
+    const auto original_dst_format = dst_info.format;
     if (src) {
-        src_info.format = src->info.format;
+        if (GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+            src_info.format = src->info.format;
+        }
+        is_resolve = src->info.num_samples > 1;
         src_info.num_samples = src->info.num_samples;
         src_info.size = src->info.size;
     }
-    if (dst) {
+    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
         dst_info.format = dst->info.format;
-        dst_info.num_samples = dst->info.num_samples;
-        dst_info.size = dst->info.size;
     }
     if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
         if (dst) {
-            src_info.format = dst_info.format;
+            if (GetFormatType(dst->info.format) == SurfaceType::ColorTexture) {
+                src_info.format = original_src_format;
+            }
         } else {
             dst_info.format = src->info.format;
         }
@@ -1171,18 +1177,13 @@ void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase*
     if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
         if (src) {
             if (GetFormatType(src->info.format) == SurfaceType::ColorTexture) {
-                dst_info.format = src->info.format;
+                dst_info.format = original_dst_format;
             }
         } else {
             src_info.format = dst->info.format;
         }
     }
-    if (src_info.num_samples > 1) {
-        dst_info.format = src_info.format;
-    }
-    if (dst_info.num_samples > 1) {
-        src_info.format = dst_info.format;
-    }
+    ASSERT(!is_resolve || dst_info.format == src_info.format);
 }
 
 u32 MapSizeBytes(const ImageBase& image) {
-- 
cgit v1.2.3


From 0857f82913d0bcf2de4721233f74cd40ecddcdae Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 20 Nov 2021 06:15:29 +0100
Subject: TextureCache: Implement buffer copies on Vulkan.

---
 .../renderer_opengl/gl_texture_cache.cpp           |   4 +-
 src/video_core/renderer_opengl/gl_texture_cache.h  |   7 +-
 .../renderer_vulkan/vk_texture_cache.cpp           | 174 +++++++++++++++++++++
 src/video_core/renderer_vulkan/vk_texture_cache.h  |  11 +-
 src/video_core/texture_cache/texture_cache.h       |   4 +-
 src/video_core/texture_cache/texture_cache_base.h  |   2 -
 6 files changed, 193 insertions(+), 9 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index 6956535e5..e70bbec81 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -526,8 +526,8 @@ void TextureCacheRuntime::CopyImage(Image& dst_image, Image& src_image,
     }
 }
 
-void TextureCacheRuntime::ConvertImage(Image& dst, Image& src,
-                                       std::span<const VideoCommon::ImageCopy> copies) {
+void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
+                                           std::span<const VideoCommon::ImageCopy> copies) {
     LOG_DEBUG(Render_OpenGL, "Converting {} to {}", src.info.format, dst.info.format);
     format_conversion_pass.ConvertImage(dst, src, copies);
 }
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index 578f8d523..ad5157d66 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -84,9 +84,13 @@ public:
 
     u64 GetDeviceLocalMemory() const;
 
+    bool ShouldReinterpret([[maybe_unused]] Image& dst, [[maybe_unused]] Image& src) {
+        return true;
+    }
+
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
-    void ConvertImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+    void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
     void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view, bool rescaled) {
         UNIMPLEMENTED();
@@ -338,7 +342,6 @@ struct TextureCacheParams {
     static constexpr bool FRAMEBUFFER_BLITS = true;
     static constexpr bool HAS_EMULATED_COPIES = true;
     static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
-    static constexpr bool HAS_PIXEL_FORMAT_CONVERSIONS = true;
 
     using Runtime = OpenGL::TextureCacheRuntime;
     using Image = OpenGL::Image;
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index af1a11059..02215cfc2 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -308,6 +308,19 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
     };
 }
 
+[[nodiscard]] VkBufferImageCopy MakeBufferImageCopy(const VideoCommon::ImageCopy& copy, bool is_src,
+                                                    VkImageAspectFlags aspect_mask) noexcept {
+    return VkBufferImageCopy{
+        .bufferOffset = 0,
+        .bufferRowLength = 0,
+        .bufferImageHeight = 0,
+        .imageSubresource = MakeImageSubresourceLayers(
+            is_src ? copy.src_subresource : copy.dst_subresource, aspect_mask),
+        .imageOffset = MakeOffset3D(is_src ? copy.src_offset : copy.dst_offset),
+        .imageExtent = MakeExtent3D(copy.extent),
+    };
+}
+
 [[maybe_unused]] [[nodiscard]] std::vector<VkBufferCopy> TransformBufferCopies(
     std::span<const VideoCommon::BufferCopy> copies, size_t buffer_offset) {
     std::vector<VkBufferCopy> result(copies.size());
@@ -754,6 +767,167 @@ StagingBufferRef TextureCacheRuntime::DownloadStagingBuffer(size_t size) {
     return staging_buffer_pool.Request(size, MemoryUsage::Download);
 }
 
+bool TextureCacheRuntime::ShouldReinterpret(Image& dst, Image& src) {
+    if (VideoCore::Surface::GetFormatType(dst.info.format) ==
+        VideoCore::Surface::SurfaceType::DepthStencil) {
+        return !device.IsExtShaderStencilExportSupported();
+    }
+    return false;
+}
+
+[[nodiscard]] size_t NextPow2(size_t value) {
+    return static_cast<size_t>(1ULL << ((8U * sizeof(size_t)) - std::countl_zero(value - 1U)));
+}
+
+VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) {
+    const auto level = (8 * sizeof(size_t)) - std::countl_zero(needed_size - 1ULL);
+    if (buffer_commits[level]) {
+        return *buffers[level];
+    }
+    const auto new_size = NextPow2(needed_size);
+    VkBufferUsageFlags flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+                               VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
+                               VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+    buffers[level] = device.GetLogical().CreateBuffer({
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .size = new_size,
+        .usage = flags,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = nullptr,
+    });
+    buffer_commits[level] = std::make_unique<MemoryCommit>(
+        memory_allocator.Commit(buffers[level], MemoryUsage::DeviceLocal));
+    return *buffers[level];
+}
+
+void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
+                                           std::span<const VideoCommon::ImageCopy> copies) {
+    std::vector<VkBufferImageCopy> vk_in_copies(copies.size());
+    std::vector<VkBufferImageCopy> vk_out_copies(copies.size());
+    const VkImageAspectFlags src_aspect_mask = src.AspectMask();
+    const VkImageAspectFlags dst_aspect_mask = dst.AspectMask();
+
+    std::ranges::transform(copies, vk_in_copies.begin(), [src_aspect_mask](const auto& copy) {
+        return MakeBufferImageCopy(copy, true, src_aspect_mask);
+    });
+    std::ranges::transform(copies, vk_out_copies.begin(), [dst_aspect_mask](const auto& copy) {
+        return MakeBufferImageCopy(copy, false, dst_aspect_mask);
+    });
+    const u32 img_bpp = BytesPerBlock(src.info.format);
+    size_t total_size = 0;
+    for (const auto& copy : copies) {
+        total_size += copy.extent.width * copy.extent.height * copy.extent.depth * img_bpp;
+    }
+    const VkBuffer copy_buffer = GetTemporaryBuffer(total_size);
+    const VkImage dst_image = dst.Handle();
+    const VkImage src_image = src.Handle();
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([dst_image, src_image, copy_buffer, src_aspect_mask, dst_aspect_mask,
+                      vk_in_copies, vk_out_copies](vk::CommandBuffer cmdbuf) {
+        RangedBarrierRange dst_range;
+        RangedBarrierRange src_range;
+        for (const VkBufferImageCopy& copy : vk_in_copies) {
+            src_range.AddLayers(copy.imageSubresource);
+        }
+        for (const VkBufferImageCopy& copy : vk_out_copies) {
+            dst_range.AddLayers(copy.imageSubresource);
+        }
+        static constexpr VkMemoryBarrier READ_BARRIER{
+            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        };
+        static constexpr VkMemoryBarrier WRITE_BARRIER{
+            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
+        };
+        const std::array pre_barriers{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = src_image,
+                .subresourceRange = src_range.SubresourceRange(src_aspect_mask),
+            },
+        };
+        const std::array middle_in_barrier{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                .dstAccessMask = 0,
+                .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = src_image,
+                .subresourceRange = src_range.SubresourceRange(src_aspect_mask),
+            },
+        };
+        const std::array middle_out_barrier{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = dst_image,
+                .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
+            },
+        };
+        const std::array post_barriers{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
+                                 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = dst_image,
+                .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
+            },
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               0, {}, {}, pre_barriers);
+
+        cmdbuf.CopyImageToBuffer(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, copy_buffer,
+                                 vk_in_copies);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                               0, WRITE_BARRIER, nullptr, middle_in_barrier);
+
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               0, READ_BARRIER, {}, middle_out_barrier);
+        cmdbuf.CopyBufferToImage(copy_buffer, dst_image, VK_IMAGE_LAYOUT_GENERAL, vk_out_copies);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                               0, {}, {}, post_barriers);
+    });
+}
+
 void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst, ImageView& src,
                                     const Region2D& dst_region, const Region2D& src_region,
                                     Tegra::Engines::Fermi2D::Filter filter,
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index f5f8f9a74..44e9dcee4 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -61,6 +61,10 @@ public:
 
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
+    bool ShouldReinterpret(Image& dst, Image& src);
+
+    void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+
     void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view, bool rescaled);
 
     bool CanAccelerateImageUpload(Image&) const noexcept {
@@ -82,6 +86,8 @@ public:
         return true;
     }
 
+    [[nodiscard]] VkBuffer GetTemporaryBuffer(size_t needed_size);
+
     const Device& device;
     VKScheduler& scheduler;
     MemoryAllocator& memory_allocator;
@@ -90,6 +96,10 @@ public:
     ASTCDecoderPass& astc_decoder_pass;
     RenderPassCache& render_pass_cache;
     const Settings::ResolutionScalingInfo& resolution;
+
+    constexpr static size_t indexing_slots = 8 * sizeof(size_t);
+    std::array<vk::Buffer, indexing_slots> buffers{};
+    std::array<std::unique_ptr<MemoryCommit>, indexing_slots> buffer_commits{};
 };
 
 class Image : public VideoCommon::ImageBase {
@@ -316,7 +326,6 @@ struct TextureCacheParams {
     static constexpr bool FRAMEBUFFER_BLITS = false;
     static constexpr bool HAS_EMULATED_COPIES = false;
     static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
-    static constexpr bool HAS_PIXEL_FORMAT_CONVERSIONS = false;
 
     using Runtime = Vulkan::TextureCacheRuntime;
     using Image = Vulkan::Image;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 4188f93c5..44a0d42ba 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1762,8 +1762,8 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
     }
     UNIMPLEMENTED_IF(dst.info.type != ImageType::e2D);
     UNIMPLEMENTED_IF(src.info.type != ImageType::e2D);
-    if constexpr (HAS_PIXEL_FORMAT_CONVERSIONS) {
-        return runtime.ConvertImage(dst, src, copies);
+    if (runtime.ShouldReinterpret(dst, src)) {
+        return runtime.ReinterpretImage(dst, src, copies);
     }
     for (const ImageCopy& copy : copies) {
         UNIMPLEMENTED_IF(copy.dst_subresource.num_layers != 1);
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index a9504c0e8..643ad811c 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -59,8 +59,6 @@ class TextureCache {
     static constexpr bool HAS_EMULATED_COPIES = P::HAS_EMULATED_COPIES;
     /// True when the API can provide info about the memory of the device.
     static constexpr bool HAS_DEVICE_MEMORY_INFO = P::HAS_DEVICE_MEMORY_INFO;
-    /// True when the API provides utilities for pixel format conversions.
-    static constexpr bool HAS_PIXEL_FORMAT_CONVERSIONS = P::HAS_PIXEL_FORMAT_CONVERSIONS;
 
     static constexpr u64 DEFAULT_EXPECTED_MEMORY = 1_GiB;
     static constexpr u64 DEFAULT_CRITICAL_MEMORY = 2_GiB;
-- 
cgit v1.2.3


From 779f4ac72d2ea2788c2106c8d2d1ec0e01b77b81 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 21 Nov 2021 05:32:34 +0100
Subject: TextureCache: Eliminate format deduction as full depth conversion has
 been supported.

---
 src/video_core/texture_cache/texture_cache.h |  6 ++----
 src/video_core/texture_cache/util.cpp        | 28 +++-------------------------
 2 files changed, 5 insertions(+), 29 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 44a0d42ba..0e4907c53 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1079,7 +1079,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
 template <class P>
 typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
     const Tegra::Engines::Fermi2D::Surface& dst, const Tegra::Engines::Fermi2D::Surface& src) {
-    static constexpr auto FIND_OPTIONS = RelaxedOptions::Format | RelaxedOptions::Samples;
+    static constexpr auto FIND_OPTIONS = RelaxedOptions::Samples;
     const GPUVAddr dst_addr = dst.Address();
     const GPUVAddr src_addr = src.Address();
     ImageInfo dst_info(dst);
@@ -1093,9 +1093,7 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
         const ImageBase* const dst_image = dst_id ? &slot_images[dst_id] : nullptr;
         const ImageBase* const src_image = src_id ? &slot_images[src_id] : nullptr;
         DeduceBlitImages(dst_info, src_info, dst_image, src_image);
-        if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
-            continue;
-        }
+        ASSERT(GetFormatType(dst_info.format) == GetFormatType(src_info.format));
         RelaxedOptions find_options{};
         if (src_info.num_samples > 1) {
             // it's a resolve, we must enforce the same format.
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index e4d82631e..777503488 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1152,36 +1152,14 @@ bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src) {
     bool is_resolve = false;
-    const auto original_src_format = src_info.format;
-    const auto original_dst_format = dst_info.format;
     if (src) {
-        if (GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
-            src_info.format = src->info.format;
-        }
         is_resolve = src->info.num_samples > 1;
         src_info.num_samples = src->info.num_samples;
         src_info.size = src->info.size;
     }
-    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
-        dst_info.format = dst->info.format;
-    }
-    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
-        if (dst) {
-            if (GetFormatType(dst->info.format) == SurfaceType::ColorTexture) {
-                src_info.format = original_src_format;
-            }
-        } else {
-            dst_info.format = src->info.format;
-        }
-    }
-    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
-        if (src) {
-            if (GetFormatType(src->info.format) == SurfaceType::ColorTexture) {
-                dst_info.format = original_dst_format;
-            }
-        } else {
-            src_info.format = dst->info.format;
-        }
+    if (dst) {
+        dst_info.num_samples = dst->info.num_samples;
+        dst_info.size = dst->info.size;
     }
     ASSERT(!is_resolve || dst_info.format == src_info.format);
 }
-- 
cgit v1.2.3


From 853284943901560081f6ff992b6c04b7c33f0d21 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Mon, 22 Nov 2021 00:00:01 +0100
Subject: TextureCache: Simplify blitting of D24S8 formats and fix bugs.

---
 src/video_core/host_shaders/CMakeLists.txt         |  4 -
 .../host_shaders/convert_b10g11r11_to_d24s8.frag   | 27 ------
 .../host_shaders/convert_d24s8_to_b10g11r11.frag   | 32 -------
 .../host_shaders/convert_d24s8_to_r16g16.frag      | 22 -----
 .../host_shaders/convert_r16g16_to_d24s8.frag      | 19 -----
 src/video_core/renderer_vulkan/blit_image.cpp      | 98 +++++++++++-----------
 src/video_core/renderer_vulkan/blit_image.h        | 25 +-----
 .../renderer_vulkan/vk_texture_cache.cpp           | 30 ++-----
 src/video_core/renderer_vulkan/vk_texture_cache.h  |  3 +
 src/video_core/texture_cache/texture_cache.h       |  8 +-
 10 files changed, 73 insertions(+), 195 deletions(-)
 delete mode 100644 src/video_core/host_shaders/convert_b10g11r11_to_d24s8.frag
 delete mode 100644 src/video_core/host_shaders/convert_d24s8_to_b10g11r11.frag
 delete mode 100644 src/video_core/host_shaders/convert_d24s8_to_r16g16.frag
 delete mode 100644 src/video_core/host_shaders/convert_r16g16_to_d24s8.frag

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txt
index 1c91999d7..fd3e41434 100644
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -11,13 +11,9 @@ set(SHADER_FILES
     block_linear_unswizzle_2d.comp
     block_linear_unswizzle_3d.comp
     convert_abgr8_to_d24s8.frag
-    convert_b10g11r11_to_d24s8.frag
     convert_d24s8_to_abgr8.frag
-    convert_d24s8_to_b10g11r11.frag
-    convert_d24s8_to_r16g16.frag
     convert_depth_to_float.frag
     convert_float_to_depth.frag
-    convert_r16g16_to_d24s8.frag
     full_screen_triangle.vert
     fxaa.frag
     fxaa.vert
diff --git a/src/video_core/host_shaders/convert_b10g11r11_to_d24s8.frag b/src/video_core/host_shaders/convert_b10g11r11_to_d24s8.frag
deleted file mode 100644
index 11bdd861d..000000000
--- a/src/video_core/host_shaders/convert_b10g11r11_to_d24s8.frag
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#version 450
-#extension GL_ARB_shader_stencil_export : require
-
-layout(binding = 0) uniform sampler2D color_texture;
-
-uint conv_from_float(float value_f, uint mantissa_bits) {
-    uint value = floatBitsToInt(value_f);
-    uint exp = (value >> 23) & 0x1Fu;
-    uint mantissa_shift = 32u - mantissa_bits;
-    uint mantissa = (value << 9u) >> mantissa_shift;
-    return (exp << mantissa_bits) | mantissa;
-}
-
-void main() {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    vec4 color = texelFetch(color_texture, coord, 0).rgba;
-    uint depth_stencil_unorm = (conv_from_float(color.r, 6u) << 21)
-                      | (conv_from_float(color.g, 6u) << 10)
-                      | conv_from_float(color.b, 5u);
-
-    gl_FragDepth = float(depth_stencil_unorm & 0x00FFFFFFu) / (exp2(24.0) - 1.0f);
-    gl_FragStencilRefARB = int(depth_stencil_unorm >> 24);
-}
diff --git a/src/video_core/host_shaders/convert_d24s8_to_b10g11r11.frag b/src/video_core/host_shaders/convert_d24s8_to_b10g11r11.frag
deleted file mode 100644
index c2d935fcd..000000000
--- a/src/video_core/host_shaders/convert_d24s8_to_b10g11r11.frag
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#version 450
-
-layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
-
-layout(location = 0) out vec4 color;
-
-float conv_to_float(uint value, uint mantissa_bits) {
-    uint exp = (value >> mantissa_bits) & 0x1Fu;
-    uint mantissa_shift = 32u - mantissa_bits;
-    uint mantissa = (value << mantissa_shift) >> mantissa_shift;
-    return uintBitsToFloat((exp << 23) | (mantissa << (23 - mantissa_bits)));
-}
-
-void main() {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-    uint depth_stencil = (stencil << 24) | (depth >> 8);
-    uint red_int = (depth_stencil >> 21) & 0x07FF;
-    uint green_int = (depth_stencil >> 10) & 0x07FF;
-    uint blue_int = depth_stencil & 0x03FF;
-
-    color.r = conv_to_float(red_int, 6u);
-    color.g = conv_to_float(green_int, 6u);
-    color.b = conv_to_float(blue_int, 5u);
-    color.a = 1.0f;
-}
diff --git a/src/video_core/host_shaders/convert_d24s8_to_r16g16.frag b/src/video_core/host_shaders/convert_d24s8_to_r16g16.frag
deleted file mode 100644
index c48a7ac66..000000000
--- a/src/video_core/host_shaders/convert_d24s8_to_r16g16.frag
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#version 450
-
-layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
-
-layout(location = 0) out vec4 color;
-
-void main() {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-    uint depth_stencil = (stencil << 24) | (depth >> 8);
-
-    color.r = float(depth_stencil & 0x0000FFFFu) / (exp2(16) - 1.0);
-    color.g = float(depth_stencil >> 16) / (exp2(16) - 1.0);
-    color.b = 0.0f;
-    color.a = 1.0f;
-}
diff --git a/src/video_core/host_shaders/convert_r16g16_to_d24s8.frag b/src/video_core/host_shaders/convert_r16g16_to_d24s8.frag
deleted file mode 100644
index beb2d1284..000000000
--- a/src/video_core/host_shaders/convert_r16g16_to_d24s8.frag
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#version 450
-#extension GL_ARB_shader_stencil_export : require
-
-layout(binding = 0) uniform sampler2D color_texture;
-
-void main() {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    vec4 color = texelFetch(color_texture, coord, 0).rgba;
-    uvec2 bytes = uvec2(color.rg * (exp2(16) - 1.0f)) << uvec2(0, 16);
-    uint depth_stencil_unorm =
-        uint(color.r * (exp2(16) - 1.0f)) | (uint(color.g * (exp2(16) - 1.0f)) << 16);
-
-    gl_FragDepth = float(depth_stencil_unorm & 0x00FFFFFFu) / (exp2(24.0) - 1.0f);
-    gl_FragStencilRefARB = int(depth_stencil_unorm >> 24);
-}
diff --git a/src/video_core/renderer_vulkan/blit_image.cpp b/src/video_core/renderer_vulkan/blit_image.cpp
index 28b631f73..2e69e270f 100644
--- a/src/video_core/renderer_vulkan/blit_image.cpp
+++ b/src/video_core/renderer_vulkan/blit_image.cpp
@@ -5,13 +5,9 @@
 #include <algorithm>
 
 #include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
-#include "video_core/host_shaders/convert_b10g11r11_to_d24s8_frag_spv.h"
 #include "video_core/host_shaders/convert_d24s8_to_abgr8_frag_spv.h"
-#include "video_core/host_shaders/convert_d24s8_to_b10g11r11_frag_spv.h"
-#include "video_core/host_shaders/convert_d24s8_to_r16g16_frag_spv.h"
 #include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"
 #include "video_core/host_shaders/convert_float_to_depth_frag_spv.h"
-#include "video_core/host_shaders/convert_r16g16_to_d24s8_frag_spv.h"
 #include "video_core/host_shaders/full_screen_triangle_vert_spv.h"
 #include "video_core/host_shaders/vulkan_blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
@@ -361,11 +357,7 @@ BlitImageHelper::BlitImageHelper(const Device& device_, VKScheduler& scheduler_,
       convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
       convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
       convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
-      convert_b10g11r11_to_d24s8_frag(BuildShader(device, CONVERT_B10G11R11_TO_D24S8_FRAG_SPV)),
-      convert_r16g16_to_d24s8_frag(BuildShader(device, CONVERT_R16G16_TO_D24S8_FRAG_SPV)),
       convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
-      convert_d24s8_to_b10g11r11_frag(BuildShader(device, CONVERT_D24S8_TO_B10G11R11_FRAG_SPV)),
-      convert_d24s8_to_r16g16_frag(BuildShader(device, CONVERT_D24S8_TO_R16G16_FRAG_SPV)),
       linear_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_LINEAR>)),
       nearest_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_NEAREST>)) {
     if (device.IsExtShaderStencilExportSupported()) {
@@ -461,30 +453,11 @@ void BlitImageHelper::ConvertR16ToD16(const Framebuffer* dst_framebuffer,
 }
 
 void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
-                                          const ImageView& src_image_view, u32 up_scale,
-                                          u32 down_shift) {
+                                          ImageView& src_image_view, u32 up_scale, u32 down_shift) {
     ConvertPipelineDepthTargetEx(convert_abgr8_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
                                  convert_abgr8_to_d24s8_frag, true);
-    Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
-            down_shift);
-}
-
-void BlitImageHelper::ConvertB10G11R11ToD24S8(const Framebuffer* dst_framebuffer,
-                                              const ImageView& src_image_view, u32 up_scale,
-                                              u32 down_shift) {
-    ConvertPipelineDepthTargetEx(convert_b10g11r11_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
-                                 convert_b10g11r11_to_d24s8_frag, true);
-    Convert(*convert_b10g11r11_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
-            down_shift);
-}
-
-void BlitImageHelper::ConvertR16G16ToD24S8(const Framebuffer* dst_framebuffer,
-                                           const ImageView& src_image_view, u32 up_scale,
-                                           u32 down_shift) {
-    ConvertPipelineDepthTargetEx(convert_r16g16_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
-                                 convert_r16g16_to_d24s8_frag, true);
-    Convert(*convert_r16g16_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
-            down_shift);
+    ConvertColor(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
+                 down_shift);
 }
 
 void BlitImageHelper::ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer,
@@ -495,24 +468,6 @@ void BlitImageHelper::ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer,
                         down_shift);
 }
 
-void BlitImageHelper::ConvertD24S8ToB10G11R11(const Framebuffer* dst_framebuffer,
-                                              ImageView& src_image_view, u32 up_scale,
-                                              u32 down_shift) {
-    ConvertPipelineColorTargetEx(convert_d24s8_to_b10g11r11_pipeline, dst_framebuffer->RenderPass(),
-                                 convert_d24s8_to_b10g11r11_frag, false);
-    ConvertDepthStencil(*convert_d24s8_to_b10g11r11_pipeline, dst_framebuffer, src_image_view,
-                        up_scale, down_shift);
-}
-
-void BlitImageHelper::ConvertD24S8ToR16G16(const Framebuffer* dst_framebuffer,
-                                           ImageView& src_image_view, u32 up_scale,
-                                           u32 down_shift) {
-    ConvertPipelineColorTargetEx(convert_d24s8_to_r16g16_pipeline, dst_framebuffer->RenderPass(),
-                                 convert_d24s8_to_r16g16_frag, false);
-    ConvertDepthStencil(*convert_d24s8_to_r16g16_pipeline, dst_framebuffer, src_image_view,
-                        up_scale, down_shift);
-}
-
 void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                               const ImageView& src_image_view, u32 up_scale, u32 down_shift) {
     const VkPipelineLayout layout = *one_texture_pipeline_layout;
@@ -560,6 +515,53 @@ void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_frameb
     scheduler.InvalidateState();
 }
 
+void BlitImageHelper::ConvertColor(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
+                                   ImageView& src_image_view, u32 up_scale, u32 down_shift) {
+    const VkPipelineLayout layout = *one_texture_pipeline_layout;
+    const VkImageView src_view = src_image_view.ColorView();
+    const VkSampler sampler = *nearest_sampler;
+    const VkExtent2D extent{
+        .width = std::max((src_image_view.size.width * up_scale) >> down_shift, 1U),
+        .height = std::max((src_image_view.size.height * up_scale) >> down_shift, 1U),
+    };
+    scheduler.RequestRenderpass(dst_framebuffer);
+    scheduler.Record([pipeline, layout, sampler, src_view, extent, up_scale, down_shift,
+                      this](vk::CommandBuffer cmdbuf) {
+        const VkOffset2D offset{
+            .x = 0,
+            .y = 0,
+        };
+        const VkViewport viewport{
+            .x = 0.0f,
+            .y = 0.0f,
+            .width = static_cast<float>(extent.width),
+            .height = static_cast<float>(extent.height),
+            .minDepth = 0.0f,
+            .maxDepth = 0.0f,
+        };
+        const VkRect2D scissor{
+            .offset = offset,
+            .extent = extent,
+        };
+        const PushConstants push_constants{
+            .tex_scale = {viewport.width, viewport.height},
+            .tex_offset = {0.0f, 0.0f},
+        };
+        const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+        UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view);
+
+        // TODO: Barriers
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                  nullptr);
+        cmdbuf.SetViewport(0, viewport);
+        cmdbuf.SetScissor(0, scissor);
+        cmdbuf.PushConstants(layout, VK_SHADER_STAGE_VERTEX_BIT, push_constants);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    scheduler.InvalidateState();
+}
+
 void BlitImageHelper::ConvertDepthStencil(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                                           ImageView& src_image_view, u32 up_scale, u32 down_shift) {
     const VkPipelineLayout layout = *two_textures_pipeline_layout;
diff --git a/src/video_core/renderer_vulkan/blit_image.h b/src/video_core/renderer_vulkan/blit_image.h
index cec095341..0b73cf444 100644
--- a/src/video_core/renderer_vulkan/blit_image.h
+++ b/src/video_core/renderer_vulkan/blit_image.h
@@ -56,28 +56,19 @@ public:
     void ConvertR16ToD16(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
                          u32 up_scale, u32 down_shift);
 
-    void ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
+    void ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
                              u32 up_scale, u32 down_shift);
 
-    void ConvertB10G11R11ToD24S8(const Framebuffer* dst_framebuffer,
-                                 const ImageView& src_image_view, u32 up_scale, u32 down_shift);
-
-    void ConvertR16G16ToD24S8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
-                              u32 up_scale, u32 down_shift);
-
     void ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
                              u32 up_scale, u32 down_shift);
 
-    void ConvertD24S8ToB10G11R11(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
-                                 u32 up_scale, u32 down_shift);
-
-    void ConvertD24S8ToR16G16(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
-                              u32 up_scale, u32 down_shift);
-
 private:
     void Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                  const ImageView& src_image_view, u32 up_scale, u32 down_shift);
 
+    void ConvertColor(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
+                      ImageView& src_image_view, u32 up_scale, u32 down_shift);
+
     void ConvertDepthStencil(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                              ImageView& src_image_view, u32 up_scale, u32 down_shift);
 
@@ -111,11 +102,7 @@ private:
     vk::ShaderModule convert_depth_to_float_frag;
     vk::ShaderModule convert_float_to_depth_frag;
     vk::ShaderModule convert_abgr8_to_d24s8_frag;
-    vk::ShaderModule convert_b10g11r11_to_d24s8_frag;
-    vk::ShaderModule convert_r16g16_to_d24s8_frag;
     vk::ShaderModule convert_d24s8_to_abgr8_frag;
-    vk::ShaderModule convert_d24s8_to_b10g11r11_frag;
-    vk::ShaderModule convert_d24s8_to_r16g16_frag;
     vk::Sampler linear_sampler;
     vk::Sampler nearest_sampler;
 
@@ -128,11 +115,7 @@ private:
     vk::Pipeline convert_d16_to_r16_pipeline;
     vk::Pipeline convert_r16_to_d16_pipeline;
     vk::Pipeline convert_abgr8_to_d24s8_pipeline;
-    vk::Pipeline convert_b10g11r11_to_d24s8_pipeline;
-    vk::Pipeline convert_r16g16_to_d24s8_pipeline;
     vk::Pipeline convert_d24s8_to_abgr8_pipeline;
-    vk::Pipeline convert_d24s8_to_b10g11r11_pipeline;
-    vk::Pipeline convert_d24s8_to_r16g16_pipeline;
 };
 
 } // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index e1ba1bdaf..ef8ae6cb6 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -1063,21 +1063,10 @@ void TextureCacheRuntime::ConvertImage(Framebuffer* dst, ImageView& dst_view, Im
         }
         break;
     case PixelFormat::A8B8G8R8_UNORM:
-    case PixelFormat::B8G8R8A8_UNORM:
         if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
             return blit_image_helper.ConvertD24S8ToABGR8(dst, src_view, up_scale, down_shift);
         }
         break;
-    case PixelFormat::B10G11R11_FLOAT:
-        if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
-            return blit_image_helper.ConvertD24S8ToB10G11R11(dst, src_view, up_scale, down_shift);
-        }
-        break;
-    case PixelFormat::R16G16_UNORM:
-        if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
-            return blit_image_helper.ConvertD24S8ToR16G16(dst, src_view, up_scale, down_shift);
-        }
-        break;
     case PixelFormat::R32_FLOAT:
         if (src_view.format == PixelFormat::D32_FLOAT) {
             return blit_image_helper.ConvertD32ToR32(dst, src_view, up_scale, down_shift);
@@ -1089,16 +1078,7 @@ void TextureCacheRuntime::ConvertImage(Framebuffer* dst, ImageView& dst_view, Im
         }
         break;
     case PixelFormat::S8_UINT_D24_UNORM:
-        if (src_view.format == PixelFormat::A8B8G8R8_UNORM ||
-            src_view.format == PixelFormat::B8G8R8A8_UNORM) {
-            return blit_image_helper.ConvertABGR8ToD24S8(dst, src_view, up_scale, down_shift);
-        }
-        if (src_view.format == PixelFormat::B10G11R11_FLOAT) {
-            return blit_image_helper.ConvertB10G11R11ToD24S8(dst, src_view, up_scale, down_shift);
-        }
-        if (src_view.format == PixelFormat::R16G16_UNORM) {
-            return blit_image_helper.ConvertR16G16ToD24S8(dst, src_view, up_scale, down_shift);
-        }
+        return blit_image_helper.ConvertABGR8ToD24S8(dst, src_view, up_scale, down_shift);
         break;
     case PixelFormat::D32_FLOAT:
         if (src_view.format == PixelFormat::R32_FLOAT) {
@@ -1595,6 +1575,14 @@ VkImageView ImageView::StencilView() {
     return *stencil_view;
 }
 
+VkImageView ImageView::ColorView() {
+    if (color_view) {
+        return *color_view;
+    }
+    color_view = MakeView(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
+    return *color_view;
+}
+
 VkImageView ImageView::StorageView(Shader::TextureType texture_type,
                                    Shader::ImageFormat image_format) {
     if (image_format == Shader::ImageFormat::Typeless) {
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index 44e9dcee4..753e3e8a1 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -184,6 +184,8 @@ public:
 
     [[nodiscard]] VkImageView StencilView();
 
+    [[nodiscard]] VkImageView ColorView();
+
     [[nodiscard]] VkImageView StorageView(Shader::TextureType texture_type,
                                           Shader::ImageFormat image_format);
 
@@ -224,6 +226,7 @@ private:
     std::unique_ptr<StorageViews> storage_views;
     vk::ImageView depth_view;
     vk::ImageView stencil_view;
+    vk::ImageView color_view;
     VkImage image_handle = VK_NULL_HANDLE;
     VkImageView render_target = VK_NULL_HANDLE;
     VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 0e4907c53..9548abec8 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1781,7 +1781,13 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
         const SubresourceExtent src_extent{.levels = 1, .layers = 1};
         const SubresourceRange dst_range{.base = dst_base, .extent = dst_extent};
         const SubresourceRange src_range{.base = src_base, .extent = src_extent};
-        const ImageViewInfo dst_view_info(ImageViewType::e2D, dst.info.format, dst_range);
+        PixelFormat dst_format = dst.info.format;
+        if (GetFormatType(src.info.format) == SurfaceType::DepthStencil &&
+            GetFormatType(dst_format) == SurfaceType::ColorTexture &&
+            BytesPerBlock(dst_format) == 4) {
+            dst_format = PixelFormat::A8B8G8R8_UNORM;
+        }
+        const ImageViewInfo dst_view_info(ImageViewType::e2D, dst_format, dst_range);
         const ImageViewInfo src_view_info(ImageViewType::e2D, src.info.format, src_range);
         const auto [dst_framebuffer_id, dst_view_id] = RenderTargetFromImage(dst_id, dst_view_info);
         Framebuffer* const dst_framebuffer = &slot_framebuffers[dst_framebuffer_id];
-- 
cgit v1.2.3


From 08674aee87e385e5f2a3b8e1b9aa85a61e23a490 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Mon, 22 Nov 2021 06:07:21 +0100
Subject: Texture Cache: Fix issue with blitting 3D textures.

---
 src/video_core/texture_cache/util.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index 777503488..9b1613008 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1155,11 +1155,13 @@ void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase*
     if (src) {
         is_resolve = src->info.num_samples > 1;
         src_info.num_samples = src->info.num_samples;
-        src_info.size = src->info.size;
+        src_info.size.width = src->info.size.width;
+        src_info.size.height = src->info.size.height;
     }
     if (dst) {
         dst_info.num_samples = dst->info.num_samples;
-        dst_info.size = dst->info.size;
+        dst_info.size.width = dst->info.size.width;
+        dst_info.size.height = dst->info.size.height;
     }
     ASSERT(!is_resolve || dst_info.format == src_info.format);
 }
-- 
cgit v1.2.3


From 1624f307d0ebd68751b567f6a616f635567754fa Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 26 Nov 2021 17:03:48 +0100
Subject: Texture Cache: Further fix regressions.

---
 src/video_core/texture_cache/texture_cache.h | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 9548abec8..570da2b04 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1088,19 +1088,23 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
     ImageId src_id;
     do {
         has_deleted_images = false;
-        dst_id = FindImage(dst_info, dst_addr, FIND_OPTIONS);
         src_id = FindImage(src_info, src_addr, FIND_OPTIONS);
-        const ImageBase* const dst_image = dst_id ? &slot_images[dst_id] : nullptr;
         const ImageBase* const src_image = src_id ? &slot_images[src_id] : nullptr;
-        DeduceBlitImages(dst_info, src_info, dst_image, src_image);
-        ASSERT(GetFormatType(dst_info.format) == GetFormatType(src_info.format));
-        RelaxedOptions find_options{};
-        if (src_info.num_samples > 1) {
-            // it's a resolve, we must enforce the same format.
-            find_options = RelaxedOptions::ForceBrokenViews;
-        }
-        src_id = FindOrInsertImage(src_info, src_addr, find_options);
-        dst_id = FindOrInsertImage(dst_info, dst_addr, find_options);
+        if (src_image && src_image->info.num_samples > 1) {
+            RelaxedOptions find_options{FIND_OPTIONS | RelaxedOptions::ForceBrokenViews};
+            src_id = FindOrInsertImage(src_info, src_addr, find_options);
+            dst_id = FindOrInsertImage(dst_info, dst_addr, find_options);
+            if (has_deleted_images) {
+                continue;
+            }
+        }
+        dst_id = FindImage(dst_info, dst_addr, FIND_OPTIONS);
+        if (!src_id) {
+            src_id = InsertImage(src_info, src_addr, RelaxedOptions{});
+        }
+        if (!dst_id) {
+            dst_id = InsertImage(dst_info, dst_addr, RelaxedOptions{});
+        }
     } while (has_deleted_images);
     return BlitImages{
         .dst_id = dst_id,
-- 
cgit v1.2.3


From ecefc932e64bf4ab8442d3c9808a2e54429e7001 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 26 Nov 2021 21:36:53 +0100
Subject: Texture Cache: Redesigning the blitting system (again).

---
 src/video_core/texture_cache/texture_cache.h      | 52 +++++++++++++++++++----
 src/video_core/texture_cache/texture_cache_base.h |  3 +-
 src/video_core/texture_cache/util.cpp             | 32 ++++++++------
 3 files changed, 64 insertions(+), 23 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 570da2b04..f24de9a38 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -472,7 +472,7 @@ template <class P>
 void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
                                 const Tegra::Engines::Fermi2D::Surface& src,
                                 const Tegra::Engines::Fermi2D::Config& copy) {
-    const BlitImages images = GetBlitImages(dst, src);
+    const BlitImages images = GetBlitImages(dst, src, copy);
     const ImageId dst_id = images.dst_id;
     const ImageId src_id = images.src_id;
 
@@ -762,12 +762,15 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
     const bool broken_views =
         runtime.HasBrokenTextureViewFormats() || True(options & RelaxedOptions::ForceBrokenViews);
     const bool native_bgr = runtime.HasNativeBgr();
-    ImageId image_id;
+    const bool flexible_formats = True(options & RelaxedOptions::Format);
+    ImageId image_id{};
+    boost::container::small_vector<ImageId, 1> image_ids;
     const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
         if (True(existing_image.flags & ImageFlagBits::Remapped)) {
             return false;
         }
-        if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) {
+        if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear)
+            [[unlikely]] {
             const bool strict_size = False(options & RelaxedOptions::Size) &&
                                      True(existing_image.flags & ImageFlagBits::Strong);
             const ImageInfo& existing = existing_image.info;
@@ -776,17 +779,27 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
                 IsPitchLinearSameSize(existing, info, strict_size) &&
                 IsViewCompatible(existing.format, info.format, broken_views, native_bgr)) {
                 image_id = existing_image_id;
-                return true;
+                image_ids.push_back(existing_image_id);
+                return !flexible_formats && existing.format == info.format;
             }
         } else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views,
                                  native_bgr)) {
             image_id = existing_image_id;
-            return true;
+            image_ids.push_back(existing_image_id);
+            return !flexible_formats && existing_image.info.format == info.format;
         }
         return false;
     };
     ForEachImageInRegion(*cpu_addr, CalculateGuestSizeInBytes(info), lambda);
-    return image_id;
+    if (image_ids.size() <= 1) [[likely]] {
+        return image_id;
+    }
+    auto image_ids_compare = [this](ImageId a, ImageId b) {
+        auto& image_a = slot_images[a];
+        auto& image_b = slot_images[b];
+        return image_a.modification_tick < image_b.modification_tick;
+    };
+    return *std::ranges::max_element(image_ids, image_ids_compare);
 }
 
 template <class P>
@@ -1078,17 +1091,26 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
 
 template <class P>
 typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
-    const Tegra::Engines::Fermi2D::Surface& dst, const Tegra::Engines::Fermi2D::Surface& src) {
+    const Tegra::Engines::Fermi2D::Surface& dst, const Tegra::Engines::Fermi2D::Surface& src,
+    const Tegra::Engines::Fermi2D::Config& copy) {
+
     static constexpr auto FIND_OPTIONS = RelaxedOptions::Samples;
     const GPUVAddr dst_addr = dst.Address();
     const GPUVAddr src_addr = src.Address();
     ImageInfo dst_info(dst);
     ImageInfo src_info(src);
+    const bool can_be_depth_blit =
+        dst_info.format == src_info.format && copy.filter == Tegra::Engines::Fermi2D::Filter::Point;
     ImageId dst_id;
     ImageId src_id;
+    RelaxedOptions try_options = FIND_OPTIONS;
+    if (can_be_depth_blit) {
+        try_options |= RelaxedOptions::Format;
+    }
     do {
         has_deleted_images = false;
-        src_id = FindImage(src_info, src_addr, FIND_OPTIONS);
+        src_id = FindImage(src_info, src_addr, try_options);
+        dst_id = FindImage(dst_info, dst_addr, try_options);
         const ImageBase* const src_image = src_id ? &slot_images[src_id] : nullptr;
         if (src_image && src_image->info.num_samples > 1) {
             RelaxedOptions find_options{FIND_OPTIONS | RelaxedOptions::ForceBrokenViews};
@@ -1097,8 +1119,15 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
             if (has_deleted_images) {
                 continue;
             }
+            break;
+        }
+        if (can_be_depth_blit) {
+            const ImageBase* const dst_image = src_id ? &slot_images[src_id] : nullptr;
+            DeduceBlitImages(dst_info, src_info, dst_image, src_image);
+            if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
+                continue;
+            }
         }
-        dst_id = FindImage(dst_info, dst_addr, FIND_OPTIONS);
         if (!src_id) {
             src_id = InsertImage(src_info, src_addr, RelaxedOptions{});
         }
@@ -1106,6 +1135,11 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
             dst_id = InsertImage(dst_info, dst_addr, RelaxedOptions{});
         }
     } while (has_deleted_images);
+    if (GetFormatType(dst_info.format) != SurfaceType::ColorTexture) {
+        // Make sure the images are depth and/or stencil textures.
+        src_id = FindOrInsertImage(src_info, src_addr, RelaxedOptions{});
+        dst_id = FindOrInsertImage(dst_info, dst_addr, RelaxedOptions{});
+    }
     return BlitImages{
         .dst_id = dst_id,
         .src_id = src_id,
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 643ad811c..7107887a6 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -252,7 +252,8 @@ private:
 
     /// Return a blit image pair from the given guest blit parameters
     [[nodiscard]] BlitImages GetBlitImages(const Tegra::Engines::Fermi2D::Surface& dst,
-                                           const Tegra::Engines::Fermi2D::Surface& src);
+                                           const Tegra::Engines::Fermi2D::Surface& src,
+                                           const Tegra::Engines::Fermi2D::Config& copy);
 
     /// Find or create a sampler from a guest descriptor sampler
     [[nodiscard]] SamplerId FindSampler(const TSCEntry& config);
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index 9b1613008..7bd31b211 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1151,19 +1151,25 @@ bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src) {
-    bool is_resolve = false;
-    if (src) {
-        is_resolve = src->info.num_samples > 1;
-        src_info.num_samples = src->info.num_samples;
-        src_info.size.width = src->info.size.width;
-        src_info.size.height = src->info.size.height;
-    }
-    if (dst) {
-        dst_info.num_samples = dst->info.num_samples;
-        dst_info.size.width = dst->info.size.width;
-        dst_info.size.height = dst->info.size.height;
-    }
-    ASSERT(!is_resolve || dst_info.format == src_info.format);
+    const auto original_dst_format = dst_info.format;
+    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+        src_info.format = src->info.format;
+    }
+    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
+        dst_info.format = dst->info.format;
+    }
+    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+        dst_info.format = src->info.format;
+    }
+    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
+        if (src) {
+            if (GetFormatType(src->info.format) == SurfaceType::ColorTexture) {
+                dst_info.format = original_dst_format;
+            }
+        } else {
+            src_info.format = dst->info.format;
+        }
+    }
 }
 
 u32 MapSizeBytes(const ImageBase& image) {
-- 
cgit v1.2.3


From 5a3463bc2b1489dda6b5fe90110f9260f6b68463 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 27 Nov 2021 23:49:56 +0100
Subject: Texture Cache: Secure insertions against deletions.

---
 src/video_core/texture_cache/texture_cache.h | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index f24de9a38..565b99254 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1137,8 +1137,11 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
     } while (has_deleted_images);
     if (GetFormatType(dst_info.format) != SurfaceType::ColorTexture) {
         // Make sure the images are depth and/or stencil textures.
-        src_id = FindOrInsertImage(src_info, src_addr, RelaxedOptions{});
-        dst_id = FindOrInsertImage(dst_info, dst_addr, RelaxedOptions{});
+        do {
+            has_deleted_images = false;
+            src_id = FindOrInsertImage(src_info, src_addr, RelaxedOptions{});
+            dst_id = FindOrInsertImage(dst_info, dst_addr, RelaxedOptions{});
+        } while (has_deleted_images);
     }
     return BlitImages{
         .dst_id = dst_id,
@@ -1196,7 +1199,14 @@ template <class P>
 ImageViewId TextureCache<P>::FindRenderTargetView(const ImageInfo& info, GPUVAddr gpu_addr,
                                                   bool is_clear) {
     const auto options = is_clear ? RelaxedOptions::Samples : RelaxedOptions{};
-    const ImageId image_id = FindOrInsertImage(info, gpu_addr, options);
+    ImageId image_id{};
+    bool delete_state = has_deleted_images;
+    do {
+        has_deleted_images = false;
+        image_id = FindOrInsertImage(info, gpu_addr, options);
+        delete_state |= has_deleted_images;
+    } while (has_deleted_images);
+    has_deleted_images = delete_state;
     if (!image_id) {
         return NULL_IMAGE_VIEW_ID;
     }
-- 
cgit v1.2.3


From 524a9baa7ea33125d5e6ba48f277c81fb7a612e3 Mon Sep 17 00:00:00 2001
From: Feng Chen <vonchenplus@gmail.com>
Date: Mon, 29 Nov 2021 12:39:37 +0800
Subject: Add missing pixel format mapping

---
 src/video_core/texture_cache/format_lookup_table.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/format_lookup_table.cpp b/src/video_core/texture_cache/format_lookup_table.cpp
index ddfb726fe..afa807d5d 100644
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@@ -139,6 +139,8 @@ PixelFormat PixelFormatFromTextureInfo(TextureFormat format, ComponentType red,
         return PixelFormat::D16_UNORM;
     case Hash(TextureFormat::S8D24, UINT, UNORM, UNORM, UNORM, LINEAR):
         return PixelFormat::S8_UINT_D24_UNORM;
+    case Hash(TextureFormat::S8D24, UINT, UNORM, UINT, UINT, LINEAR):
+        return PixelFormat::S8_UINT_D24_UNORM;
     case Hash(TextureFormat::R8G24, UINT, UNORM, UNORM, UNORM, LINEAR):
         return PixelFormat::S8_UINT_D24_UNORM;
     case Hash(TextureFormat::D32S8, FLOAT, UINT, UNORM, UNORM, LINEAR):
-- 
cgit v1.2.3


From a5c212516cc4ca73807e03ab7c40e469ecabd061 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 4 Dec 2021 10:20:28 +0100
Subject: Texture Cache: Fix crashes on NVIDIA.

---
 src/video_core/texture_cache/texture_cache.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 565b99254..e195b1e98 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1122,7 +1122,7 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
             break;
         }
         if (can_be_depth_blit) {
-            const ImageBase* const dst_image = src_id ? &slot_images[src_id] : nullptr;
+            const ImageBase* const dst_image = dst_id ? &slot_images[dst_id] : nullptr;
             DeduceBlitImages(dst_info, src_info, dst_image, src_image);
             if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
                 continue;
@@ -1135,8 +1135,11 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
             dst_id = InsertImage(dst_info, dst_addr, RelaxedOptions{});
         }
     } while (has_deleted_images);
-    if (GetFormatType(dst_info.format) != SurfaceType::ColorTexture) {
-        // Make sure the images are depth and/or stencil textures.
+    const ImageBase& src_image = slot_images[src_id];
+    const ImageBase& dst_image = slot_images[dst_id];
+    if (GetFormatType(dst_info.format) != GetFormatType(dst_image.info.format) ||
+        GetFormatType(src_info.format) != GetFormatType(src_image.info.format)) {
+        // Make sure the images match the expected format.
         do {
             has_deleted_images = false;
             src_id = FindOrInsertImage(src_info, src_addr, RelaxedOptions{});
-- 
cgit v1.2.3


From 159842649392a2328de5f258ce742c4361f51f60 Mon Sep 17 00:00:00 2001
From: Feng Chen <vonchenplus@gmail.com>
Date: Fri, 10 Dec 2021 12:03:34 +0800
Subject: Fix blit image/view not compatible

---
 src/video_core/texture_cache/texture_cache.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index e195b1e98..5aaeb16ca 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1137,8 +1137,13 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
     } while (has_deleted_images);
     const ImageBase& src_image = slot_images[src_id];
     const ImageBase& dst_image = slot_images[dst_id];
+    const bool native_bgr = runtime.HasNativeBgr();
     if (GetFormatType(dst_info.format) != GetFormatType(dst_image.info.format) ||
-        GetFormatType(src_info.format) != GetFormatType(src_image.info.format)) {
+        GetFormatType(src_info.format) != GetFormatType(src_image.info.format) ||
+        !VideoCore::Surface::IsViewCompatible(dst_info.format, dst_image.info.format, false,
+                                              native_bgr) ||
+        !VideoCore::Surface::IsViewCompatible(src_info.format, src_image.info.format, false,
+                                              native_bgr)) {
         // Make sure the images match the expected format.
         do {
             has_deleted_images = false;
-- 
cgit v1.2.3