From 22f4b290b6f0894d29302102f539dd8753961f04 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sun, 18 Jul 2021 18:40:14 +0200
Subject: VideoCore: Initial Setup for the Resolution Scaler.

---
 src/video_core/texture_cache/image_base.h         |   4 +
 src/video_core/texture_cache/image_info.h         |   2 +-
 src/video_core/texture_cache/texture_cache.h      | 113 +++++++++++++++++++++-
 src/video_core/texture_cache/texture_cache_base.h |  10 ++
 4 files changed, 126 insertions(+), 3 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 0c17a791b..1cd30fd37 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -33,6 +33,10 @@ enum class ImageFlagBits : u32 {
                           ///< garbage collection priority
     Alias = 1 << 11,      ///< This image has aliases and has priority on garbage
                           ///< collection
+
+    // Rescaler
+    Rescaled = 1 << 12,
+    RescaleChecked = 1 << 13,
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
diff --git a/src/video_core/texture_cache/image_info.h b/src/video_core/texture_cache/image_info.h
index 5049fc36e..16d4cee37 100644
--- a/src/video_core/texture_cache/image_info.h
+++ b/src/video_core/texture_cache/image_info.h
@@ -15,7 +15,7 @@ using Tegra::Texture::TICEntry;
 using VideoCore::Surface::PixelFormat;
 
 struct ImageInfo {
-    explicit ImageInfo() = default;
+    ImageInfo() = default;
     explicit ImageInfo(const TICEntry& config) noexcept;
     explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index) noexcept;
     explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index f70c1f764..560da4f16 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -35,6 +35,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
                               Tegra::MemoryManager& gpu_memory_)
     : runtime{runtime_}, rasterizer{rasterizer_}, maxwell3d{maxwell3d_},
       kepler_compute{kepler_compute_}, gpu_memory{gpu_memory_} {
+    runtime.Init();
     // Configure null sampler
     TSCEntry sampler_descriptor{};
     sampler_descriptor.min_filter.Assign(Tegra::Texture::TextureFilter::Linear);
@@ -103,6 +104,7 @@ void TextureCache<P>::TickFrame() {
     sentenced_images.Tick();
     sentenced_framebuffers.Tick();
     sentenced_image_view.Tick();
+    runtime.TickFrame();
     ++frame_tick;
 }
 
@@ -208,18 +210,63 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
     const bool force = flags[Dirty::RenderTargetControl];
     flags[Dirty::RenderTargetControl] = false;
 
+    bool can_rescale = true;
+    std::array<ImageId, NUM_RT> tmp_color_images{};
+    ImageId tmp_depth_image{};
+    const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
+        if (view_id) {
+            const auto& view = slot_image_views[view_id];
+            const auto image_id = view.image_id;
+            id_save = image_id;
+            auto& image = slot_images[image_id];
+            can_rescale &= ImageCanRescale(image);
+        } else {
+            id_save = CORRUPT_ID;
+        }
+    };
     for (size_t index = 0; index < NUM_RT; ++index) {
         ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
         if (flags[Dirty::ColorBuffer0 + index] || force) {
             flags[Dirty::ColorBuffer0 + index] = false;
             BindRenderTarget(&color_buffer_id, FindColorBuffer(index, is_clear));
         }
-        PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));
+        check_rescale(color_buffer_id, tmp_color_images[index]);
     }
     if (flags[Dirty::ZetaBuffer] || force) {
         flags[Dirty::ZetaBuffer] = false;
         BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
     }
+    check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
+
+    if (can_rescale) {
+        const auto scale_up = [this](ImageId image_id) {
+            if (image_id != CORRUPT_ID) {
+                Image& image = slot_images[image_id];
+                image.ScaleUp();
+            }
+        };
+        for (size_t index = 0; index < NUM_RT; ++index) {
+            scale_up(tmp_color_images[index]);
+        }
+        scale_up(tmp_depth_image);
+    } else {
+        const auto scale_down = [this](ImageId image_id) {
+            if (image_id != CORRUPT_ID) {
+                Image& image = slot_images[image_id];
+                image.ScaleDown();
+            }
+        };
+        for (size_t index = 0; index < NUM_RT; ++index) {
+            scale_down(tmp_color_images[index]);
+        }
+        scale_down(tmp_depth_image);
+    }
+    // Rescale End
+
+    for (size_t index = 0; index < NUM_RT; ++index) {
+        ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
+        PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));
+    }
     const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
 
     PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
@@ -623,6 +670,31 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
     return image_id;
 }
 
+template <class P>
+bool TextureCache<P>::ImageCanRescale(Image& image) {
+    if (True(image.flags & ImageFlagBits::Rescaled) ||
+        True(image.flags & ImageFlagBits::RescaleChecked)) {
+        return true;
+    }
+    const auto& info = image.info;
+    const bool can_this_rescale =
+        (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
+    if (!can_this_rescale) {
+        image.flags &= ~ImageFlagBits::RescaleChecked;
+        return false;
+    }
+    image.flags |= ImageFlagBits::RescaleChecked;
+    for (const auto& alias : image.aliased_images) {
+        Image& other_image = slot_images[alias.id];
+        if (!ImageCanRescale(other_image)) {
+            image.flags &= ~ImageFlagBits::RescaleChecked;
+            return false;
+        }
+    }
+    image.flags &= ~ImageFlagBits::RescaleChecked;
+    return true;
+}
+
 template <class P>
 ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
                                      RelaxedOptions options) {
@@ -660,12 +732,18 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     std::vector<ImageId> right_aliased_ids;
     std::unordered_set<ImageId> ignore_textures;
     std::vector<ImageId> bad_overlap_ids;
+    std::vector<ImageId> all_siblings;
+    const bool this_is_linear = info.type == ImageType::Linear;
     const auto region_check = [&](ImageId overlap_id, ImageBase& overlap) {
         if (True(overlap.flags & ImageFlagBits::Remapped)) {
             ignore_textures.insert(overlap_id);
             return;
         }
-        if (info.type == ImageType::Linear) {
+        const bool overlap_is_linear = overlap.info.type == ImageType::Linear;
+        if (this_is_linear != overlap_is_linear) {
+            return;
+        }
+        if (this_is_linear && overlap_is_linear) {
             if (info.pitch == overlap.info.pitch && gpu_addr == overlap.gpu_addr) {
                 // Alias linear images with the same pitch
                 left_aliased_ids.push_back(overlap_id);
@@ -681,6 +759,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             cpu_addr = solution->cpu_addr;
             new_info.resources = solution->resources;
             overlap_ids.push_back(overlap_id);
+            all_siblings.push_back(overlap_id);
             return;
         }
         static constexpr auto options = RelaxedOptions::Size | RelaxedOptions::Format;
@@ -688,10 +767,12 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views, native_bgr)) {
             left_aliased_ids.push_back(overlap_id);
             overlap.flags |= ImageFlagBits::Alias;
+            all_siblings.push_back(overlap_id);
         } else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options,
                                  broken_views, native_bgr)) {
             right_aliased_ids.push_back(overlap_id);
             overlap.flags |= ImageFlagBits::Alias;
+            all_siblings.push_back(overlap_id);
         } else {
             bad_overlap_ids.push_back(overlap_id);
             overlap.flags |= ImageFlagBits::BadOverlap;
@@ -709,8 +790,36 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         }
     };
     ForEachSparseImageInRegion(gpu_addr, size_bytes, region_check_gpu);
+
+    bool can_rescale =
+        (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
+    for (const ImageId sibling_id : all_siblings) {
+        if (!can_rescale) {
+            break;
+        }
+        Image& sibling = slot_images[sibling_id];
+        can_rescale &= ImageCanRescale(sibling);
+    }
+
+    if (can_rescale) {
+        for (const ImageId sibling_id : all_siblings) {
+            Image& sibling = slot_images[sibling_id];
+            sibling.ScaleUp();
+        }
+    } else {
+        for (const ImageId sibling_id : all_siblings) {
+            Image& sibling = slot_images[sibling_id];
+            sibling.ScaleDown();
+        }
+    }
+
     const ImageId new_image_id = slot_images.insert(runtime, new_info, gpu_addr, cpu_addr);
     Image& new_image = slot_images[new_image_id];
+    if (can_rescale) {
+        new_image.ScaleUp();
+    } else {
+        new_image.ScaleDown();
+    }
 
     if (!gpu_memory.IsContinousRange(new_image.gpu_addr, new_image.guest_size_bytes)) {
         new_image.flags |= ImageFlagBits::Sparse;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 2d1893c1c..a4a2c0832 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -142,6 +142,14 @@ public:
                    const Tegra::Engines::Fermi2D::Surface& src,
                    const Tegra::Engines::Fermi2D::Config& copy);
 
+    /// Invalidate the contents of the color buffer index
+    /// These contents become unspecified, the cache can assume aggressive optimizations.
+    void InvalidateColorBuffer(size_t index);
+
+    /// Invalidate the contents of the depth buffer
+    /// These contents become unspecified, the cache can assume aggressive optimizations.
+    void InvalidateDepthBuffer();
+
     /// Try to find a cached image view in the given CPU address
     [[nodiscard]] ImageView* TryFindFramebufferImageView(VAddr cpu_addr);
 
@@ -318,6 +326,8 @@ private:
     /// Returns true if the current clear parameters clear the whole image of a given image view
     [[nodiscard]] bool IsFullClear(ImageViewId id);
 
+    bool ImageCanRescale(Image& image);
+
     Runtime& runtime;
     VideoCore::RasterizerInterface& rasterizer;
     Tegra::Engines::Maxwell3D& maxwell3d;
-- 
cgit v1.2.3


From ba18047e8d06584de0ce18cdbb303a6d9a8742aa Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 19 Jul 2021 04:32:03 +0200
Subject: Texture Cache: Implement Vulkan UpScaling & DownScaling

---
 src/video_core/texture_cache/image_info.cpp       |  3 +
 src/video_core/texture_cache/texture_cache.h      | 84 +++++++++++++++++++----
 src/video_core/texture_cache/texture_cache_base.h |  3 +
 3 files changed, 77 insertions(+), 13 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index 64fd7010a..022ca9033 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -41,6 +41,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         ASSERT(config.BaseLayer() == 0);
         type = ImageType::e1D;
         size.width = config.Width();
+        resources.layers = 1;
         break;
     case TextureType::Texture1DArray:
         UNIMPLEMENTED_IF(config.BaseLayer() != 0);
@@ -82,10 +83,12 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         size.width = config.Width();
         size.height = config.Height();
         size.depth = config.Depth();
+        resources.layers = 1;
         break;
     case TextureType::Texture1DBuffer:
         type = ImageType::Buffer;
         size.width = config.Width();
+        resources.layers = 1;
         break;
     default:
         UNREACHABLE_MSG("Invalid texture_type={}", static_cast<int>(config.texture_type.Value()));
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 560da4f16..95a9e8fe9 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -242,24 +242,36 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         const auto scale_up = [this](ImageId image_id) {
             if (image_id != CORRUPT_ID) {
                 Image& image = slot_images[image_id];
-                image.ScaleUp();
+                return ScaleUp(image);
             }
+            return false;
         };
         for (size_t index = 0; index < NUM_RT; ++index) {
-            scale_up(tmp_color_images[index]);
+            if (scale_up(tmp_color_images[index])) {
+                BindRenderTarget(&render_targets.color_buffer_ids[index],
+                                 FindColorBuffer(index, is_clear));
+            }
+        }
+        if (scale_up(tmp_depth_image)) {
+            BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
         }
-        scale_up(tmp_depth_image);
     } else {
         const auto scale_down = [this](ImageId image_id) {
             if (image_id != CORRUPT_ID) {
                 Image& image = slot_images[image_id];
-                image.ScaleDown();
+                return ScaleDown(image);
             }
+            return false;
         };
         for (size_t index = 0; index < NUM_RT; ++index) {
-            scale_down(tmp_color_images[index]);
+            if (scale_down(tmp_color_images[index])) {
+                BindRenderTarget(&render_targets.color_buffer_ids[index],
+                                 FindColorBuffer(index, is_clear));
+            }
+        }
+        if (scale_down(tmp_depth_image)) {
+            BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
         }
-        scale_down(tmp_depth_image);
     }
     // Rescale End
 
@@ -695,6 +707,47 @@ bool TextureCache<P>::ImageCanRescale(Image& image) {
     return true;
 }
 
+template <class P>
+void TextureCache<P>::InvalidateScale(Image& image, bool invalidate_rt) {
+    const std::span<const ImageViewId> image_view_ids = image.image_view_ids;
+    if (invalidate_rt) {
+        auto& dirty = maxwell3d.dirty.flags;
+        dirty[Dirty::RenderTargets] = true;
+        dirty[Dirty::ZetaBuffer] = true;
+        for (size_t rt = 0; rt < NUM_RT; ++rt) {
+            dirty[Dirty::ColorBuffer0 + rt] = true;
+        }
+        for (const ImageViewId image_view_id : image_view_ids) {
+            std::ranges::replace(render_targets.color_buffer_ids, image_view_id, ImageViewId{});
+            if (render_targets.depth_buffer_id == image_view_id) {
+                render_targets.depth_buffer_id = ImageViewId{};
+            }
+        }
+    }
+    RemoveImageViewReferences(image_view_ids);
+    RemoveFramebuffers(image_view_ids);
+}
+
+template <class P>
+bool TextureCache<P>::ScaleUp(Image& image, bool invalidate_rt) {
+    const bool rescaled = image.ScaleUp();
+    if (!rescaled) {
+        return false;
+    }
+    InvalidateScale(image, invalidate_rt);
+    return true;
+}
+
+template <class P>
+bool TextureCache<P>::ScaleDown(Image& image, bool invalidate_rt) {
+    const bool rescaled = image.ScaleDown();
+    if (!rescaled) {
+        return false;
+    }
+    InvalidateScale(image, invalidate_rt);
+    return true;
+}
+
 template <class P>
 ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
                                      RelaxedOptions options) {
@@ -793,33 +846,32 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
 
     bool can_rescale =
         (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
+    bool any_rescaled = false;
     for (const ImageId sibling_id : all_siblings) {
         if (!can_rescale) {
             break;
         }
         Image& sibling = slot_images[sibling_id];
         can_rescale &= ImageCanRescale(sibling);
+        any_rescaled |= True(sibling.flags & ImageFlagBits::Rescaled);
     }
 
+    can_rescale &= any_rescaled;
+
     if (can_rescale) {
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
-            sibling.ScaleUp();
+            ScaleUp(sibling, true);
         }
     } else {
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
-            sibling.ScaleDown();
+            ScaleDown(sibling, true);
         }
     }
 
     const ImageId new_image_id = slot_images.insert(runtime, new_info, gpu_addr, cpu_addr);
     Image& new_image = slot_images[new_image_id];
-    if (can_rescale) {
-        new_image.ScaleUp();
-    } else {
-        new_image.ScaleDown();
-    }
 
     if (!gpu_memory.IsContinousRange(new_image.gpu_addr, new_image.guest_size_bytes)) {
         new_image.flags |= ImageFlagBits::Sparse;
@@ -840,6 +892,12 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     // TODO: Only upload what we need
     RefreshContents(new_image, new_image_id);
 
+    if (can_rescale) {
+        new_image.ScaleUp();
+    } else {
+        new_image.ScaleDown();
+    }
+
     for (const ImageId overlap_id : overlap_ids) {
         Image& overlap = slot_images[overlap_id];
         if (overlap.info.num_samples != new_image.info.num_samples) {
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index a4a2c0832..042678786 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -327,6 +327,9 @@ private:
     [[nodiscard]] bool IsFullClear(ImageViewId id);
 
     bool ImageCanRescale(Image& image);
+    void InvalidateScale(Image& image, bool invalidate_rt = false);
+    bool ScaleUp(Image& image, bool invalidate_rt = false);
+    bool ScaleDown(Image& image, bool invalidate_rt = false);
 
     Runtime& runtime;
     VideoCore::RasterizerInterface& rasterizer;
-- 
cgit v1.2.3


From 84f2aea8962146be899131b032fcdf9b4e1f6ddf Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Tue, 20 Jul 2021 07:40:05 +0200
Subject: Texture Cache: More rescaling fixes.

---
 src/video_core/texture_cache/texture_cache.h      | 162 +++++++++++-----------
 src/video_core/texture_cache/texture_cache_base.h |   6 +-
 2 files changed, 86 insertions(+), 82 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 95a9e8fe9..b7d1ae92d 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -204,75 +204,68 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
         return;
     }
-    flags[Dirty::RenderTargets] = false;
-
-    // Render target control is used on all render targets, so force look ups when this one is up
-    const bool force = flags[Dirty::RenderTargetControl];
-    flags[Dirty::RenderTargetControl] = false;
-
-    bool can_rescale = true;
-    std::array<ImageId, NUM_RT> tmp_color_images{};
-    ImageId tmp_depth_image{};
-    const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
-        if (view_id) {
-            const auto& view = slot_image_views[view_id];
-            const auto image_id = view.image_id;
-            id_save = image_id;
-            auto& image = slot_images[image_id];
-            can_rescale &= ImageCanRescale(image);
-        } else {
-            id_save = CORRUPT_ID;
-        }
-    };
-    for (size_t index = 0; index < NUM_RT; ++index) {
-        ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
-        if (flags[Dirty::ColorBuffer0 + index] || force) {
-            flags[Dirty::ColorBuffer0 + index] = false;
-            BindRenderTarget(&color_buffer_id, FindColorBuffer(index, is_clear));
-        }
-        check_rescale(color_buffer_id, tmp_color_images[index]);
-    }
-    if (flags[Dirty::ZetaBuffer] || force) {
-        flags[Dirty::ZetaBuffer] = false;
-        BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
-    }
-    check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
 
-    if (can_rescale) {
-        const auto scale_up = [this](ImageId image_id) {
-            if (image_id != CORRUPT_ID) {
-                Image& image = slot_images[image_id];
-                return ScaleUp(image);
+    do {
+        flags[Dirty::RenderTargets] = false;
+
+        has_deleted_images = false;
+        // Render target control is used on all render targets, so force look ups when this one is
+        // up
+        const bool force = flags[Dirty::RenderTargetControl];
+        flags[Dirty::RenderTargetControl] = false;
+
+        bool can_rescale = true;
+        std::array<ImageId, NUM_RT> tmp_color_images{};
+        ImageId tmp_depth_image{};
+        const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
+            if (view_id) {
+                const auto& view = slot_image_views[view_id];
+                const auto image_id = view.image_id;
+                id_save = image_id;
+                auto& image = slot_images[image_id];
+                can_rescale &= ImageCanRescale(image);
+            } else {
+                id_save = CORRUPT_ID;
             }
-            return false;
         };
         for (size_t index = 0; index < NUM_RT; ++index) {
-            if (scale_up(tmp_color_images[index])) {
-                BindRenderTarget(&render_targets.color_buffer_ids[index],
-                                 FindColorBuffer(index, is_clear));
+            ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
+            if (flags[Dirty::ColorBuffer0 + index] || force) {
+                flags[Dirty::ColorBuffer0 + index] = false;
+                BindRenderTarget(&color_buffer_id, FindColorBuffer(index, is_clear));
             }
+            check_rescale(color_buffer_id, tmp_color_images[index]);
         }
-        if (scale_up(tmp_depth_image)) {
+        if (flags[Dirty::ZetaBuffer] || force) {
+            flags[Dirty::ZetaBuffer] = false;
             BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
         }
-    } else {
-        const auto scale_down = [this](ImageId image_id) {
-            if (image_id != CORRUPT_ID) {
-                Image& image = slot_images[image_id];
-                return ScaleDown(image);
+        check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
+
+        if (can_rescale) {
+            const auto scale_up = [this](ImageId image_id) {
+                if (image_id != CORRUPT_ID) {
+                    Image& image = slot_images[image_id];
+                    ScaleUp(image);
+                }
+            };
+            for (size_t index = 0; index < NUM_RT; ++index) {
+                scale_up(tmp_color_images[index]);
             }
-            return false;
-        };
-        for (size_t index = 0; index < NUM_RT; ++index) {
-            if (scale_down(tmp_color_images[index])) {
-                BindRenderTarget(&render_targets.color_buffer_ids[index],
-                                 FindColorBuffer(index, is_clear));
+            scale_up(tmp_depth_image);
+        } else {
+            const auto scale_down = [this](ImageId image_id) {
+                if (image_id != CORRUPT_ID) {
+                    Image& image = slot_images[image_id];
+                    ScaleDown(image);
+                }
+            };
+            for (size_t index = 0; index < NUM_RT; ++index) {
+                scale_down(tmp_color_images[index]);
             }
+            scale_down(tmp_depth_image);
         }
-        if (scale_down(tmp_depth_image)) {
-            BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
-        }
-    }
+    } while (has_deleted_images);
     // Rescale End
 
     for (size_t index = 0; index < NUM_RT; ++index) {
@@ -708,43 +701,54 @@ bool TextureCache<P>::ImageCanRescale(Image& image) {
 }
 
 template <class P>
-void TextureCache<P>::InvalidateScale(Image& image, bool invalidate_rt) {
+void TextureCache<P>::InvalidateScale(Image& image) {
     const std::span<const ImageViewId> image_view_ids = image.image_view_ids;
-    if (invalidate_rt) {
-        auto& dirty = maxwell3d.dirty.flags;
-        dirty[Dirty::RenderTargets] = true;
-        dirty[Dirty::ZetaBuffer] = true;
-        for (size_t rt = 0; rt < NUM_RT; ++rt) {
-            dirty[Dirty::ColorBuffer0 + rt] = true;
-        }
-        for (const ImageViewId image_view_id : image_view_ids) {
-            std::ranges::replace(render_targets.color_buffer_ids, image_view_id, ImageViewId{});
-            if (render_targets.depth_buffer_id == image_view_id) {
-                render_targets.depth_buffer_id = ImageViewId{};
-            }
+    auto& dirty = maxwell3d.dirty.flags;
+    dirty[Dirty::RenderTargets] = true;
+    dirty[Dirty::ZetaBuffer] = true;
+    for (size_t rt = 0; rt < NUM_RT; ++rt) {
+        dirty[Dirty::ColorBuffer0 + rt] = true;
+    }
+    for (const ImageViewId image_view_id : image_view_ids) {
+        std::ranges::replace(render_targets.color_buffer_ids, image_view_id, ImageViewId{});
+        if (render_targets.depth_buffer_id == image_view_id) {
+            render_targets.depth_buffer_id = ImageViewId{};
         }
     }
     RemoveImageViewReferences(image_view_ids);
     RemoveFramebuffers(image_view_ids);
+    for (const ImageViewId image_view_id : image_view_ids) {
+        sentenced_image_view.Push(std::move(slot_image_views[image_view_id]));
+        slot_image_views.erase(image_view_id);
+    }
+    image.image_view_ids.clear();
+    image.image_view_infos.clear();
+    if constexpr (ENABLE_VALIDATION) {
+        std::ranges::fill(graphics_image_view_ids, CORRUPT_ID);
+        std::ranges::fill(compute_image_view_ids, CORRUPT_ID);
+    }
+    graphics_image_table.Invalidate();
+    compute_image_table.Invalidate();
+    has_deleted_images = true;
 }
 
 template <class P>
-bool TextureCache<P>::ScaleUp(Image& image, bool invalidate_rt) {
+bool TextureCache<P>::ScaleUp(Image& image) {
     const bool rescaled = image.ScaleUp();
     if (!rescaled) {
         return false;
     }
-    InvalidateScale(image, invalidate_rt);
+    InvalidateScale(image);
     return true;
 }
 
 template <class P>
-bool TextureCache<P>::ScaleDown(Image& image, bool invalidate_rt) {
+bool TextureCache<P>::ScaleDown(Image& image) {
     const bool rescaled = image.ScaleDown();
     if (!rescaled) {
         return false;
     }
-    InvalidateScale(image, invalidate_rt);
+    InvalidateScale(image);
     return true;
 }
 
@@ -861,12 +865,12 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     if (can_rescale) {
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
-            ScaleUp(sibling, true);
+            ScaleUp(sibling);
         }
     } else {
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
-            ScaleDown(sibling, true);
+            ScaleDown(sibling);
         }
     }
 
@@ -893,9 +897,9 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     RefreshContents(new_image, new_image_id);
 
     if (can_rescale) {
-        new_image.ScaleUp();
+        ScaleUp(new_image);
     } else {
-        new_image.ScaleDown();
+        ScaleDown(new_image);
     }
 
     for (const ImageId overlap_id : overlap_ids) {
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 042678786..cdd99242b 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -327,9 +327,9 @@ private:
     [[nodiscard]] bool IsFullClear(ImageViewId id);
 
     bool ImageCanRescale(Image& image);
-    void InvalidateScale(Image& image, bool invalidate_rt = false);
-    bool ScaleUp(Image& image, bool invalidate_rt = false);
-    bool ScaleDown(Image& image, bool invalidate_rt = false);
+    void InvalidateScale(Image& image);
+    bool ScaleUp(Image& image);
+    bool ScaleDown(Image& image);
 
     Runtime& runtime;
     VideoCore::RasterizerInterface& rasterizer;
-- 
cgit v1.2.3


From 778700ff9d6eca96945deebcd4415e70d58330d9 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Tue, 20 Jul 2021 19:36:38 +0200
Subject: TextureCache: Modify Viewports/Scissors according to Rescale.

---
 src/video_core/texture_cache/texture_cache.h      | 25 +++++++++++++++++++++--
 src/video_core/texture_cache/texture_cache_base.h |  3 +++
 2 files changed, 26 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 b7d1ae92d..4e5031acc 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -7,6 +7,7 @@
 #include <unordered_set>
 
 #include "common/alignment.h"
+#include "common/settings.h"
 #include "video_core/dirty_flags.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/texture_cache/image_view_base.h"
@@ -205,6 +206,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         return;
     }
 
+    bool rescaled;
     do {
         flags[Dirty::RenderTargets] = false;
 
@@ -243,6 +245,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
 
         if (can_rescale) {
+            rescaled = true;
             const auto scale_up = [this](ImageId image_id) {
                 if (image_id != CORRUPT_ID) {
                     Image& image = slot_images[image_id];
@@ -254,6 +257,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
             }
             scale_up(tmp_depth_image);
         } else {
+            rescaled = false;
             const auto scale_down = [this](ImageId image_id) {
                 if (image_id != CORRUPT_ID) {
                     Image& image = slot_images[image_id];
@@ -268,6 +272,12 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
     } while (has_deleted_images);
     // Rescale End
 
+    if (is_rescaling != rescaled) {
+        flags[Dirty::RescaleViewports] = true;
+        flags[Dirty::RescaleScissors] = true;
+        is_rescaling = rescaled;
+    }
+
     for (size_t index = 0; index < NUM_RT; ++index) {
         ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
         PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));
@@ -279,9 +289,15 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
     for (size_t index = 0; index < NUM_RT; ++index) {
         render_targets.draw_buffers[index] = static_cast<u8>(maxwell3d.regs.rt_control.Map(index));
     }
+    u32 up_scale = 1;
+    u32 down_shift = 0;
+    if (is_rescaling) {
+        up_scale = Settings::values.resolution_info.up_scale;
+        down_shift = Settings::values.resolution_info.down_shift;
+    }
     render_targets.size = Extent2D{
-        maxwell3d.regs.render_area.width,
-        maxwell3d.regs.render_area.height,
+        (maxwell3d.regs.render_area.width * up_scale) >> down_shift,
+        (maxwell3d.regs.render_area.height * up_scale) >> down_shift,
     };
 
     flags[Dirty::DepthBiasGlobal] = true;
@@ -538,6 +554,11 @@ void TextureCache<P>::PopAsyncFlushes() {
     committed_downloads.pop();
 }
 
+template <class P>
+bool TextureCache<P>::IsRescaling() {
+    return is_rescaling;
+}
+
 template <class P>
 bool TextureCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
     bool is_modified = false;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index cdd99242b..1f51fcee8 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -168,6 +168,8 @@ public:
     /// Return true when a CPU region is modified from the GPU
     [[nodiscard]] bool IsRegionGpuModified(VAddr addr, size_t size);
 
+    [[nodiscard]] bool IsRescaling();
+
     std::mutex mutex;
 
 private:
@@ -362,6 +364,7 @@ private:
     VAddr virtual_invalid_space{};
 
     bool has_deleted_images = false;
+    bool is_rescaling = false;
     u64 total_used_memory = 0;
     u64 minimum_memory;
     u64 expected_memory;
-- 
cgit v1.2.3


From 8704c939136e88876d65fc670bce98d8250a6588 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Tue, 20 Jul 2021 22:51:25 +0200
Subject: TextureCache: Fix rescaling of ImageCopies

---
 src/video_core/texture_cache/texture_cache.h      | 43 ++++++++++++++++++++---
 src/video_core/texture_cache/texture_cache_base.h |  2 +-
 2 files changed, 40 insertions(+), 5 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 4e5031acc..df697cdeb 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -929,8 +929,8 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             LOG_WARNING(HW_GPU, "Copying between images with different samples is not implemented");
         } else {
             const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
-            const auto copies = MakeShrinkImageCopies(new_info, overlap.info, base);
-            runtime.CopyImage(new_image, overlap, copies);
+            auto copies = MakeShrinkImageCopies(new_info, overlap.info, base);
+            runtime.CopyImage(new_image, overlap, std::move(copies));
         }
         if (True(overlap.flags & ImageFlagBits::Tracked)) {
             UntrackImage(overlap, overlap_id);
@@ -1569,9 +1569,33 @@ void TextureCache<P>::PrepareImageView(ImageViewId image_view_id, bool is_modifi
 }
 
 template <class P>
-void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::span<const ImageCopy> copies) {
+void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<ImageCopy> copies) {
     Image& dst = slot_images[dst_id];
     Image& src = slot_images[src_id];
+    const bool is_rescaled = True(src.flags & ImageFlagBits::Rescaled);
+    if (is_rescaled) {
+        ASSERT(True(dst.flags & ImageFlagBits::Rescaled));
+        const bool both_2d{src.info.type == ImageType::e2D && dst.info.type == ImageType::e2D};
+        const auto& resolution = Settings::values.resolution_info;
+        const auto scale_up = [&](u32 value) -> u32 {
+            if (value == 0) {
+                return 0U;
+            }
+            return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
+        };
+        for (auto& copy : copies) {
+            copy.src_offset.x = scale_up(copy.src_offset.x);
+
+            copy.dst_offset.x = scale_up(copy.dst_offset.x);
+
+            copy.extent.width = scale_up(copy.extent.width);
+            if (both_2d) {
+                copy.src_offset.y = scale_up(copy.src_offset.y);
+                copy.dst_offset.y = scale_up(copy.dst_offset.y);
+                copy.extent.height = scale_up(copy.extent.height);
+            }
+        }
+    }
     const auto dst_format_type = GetFormatType(dst.info.format);
     const auto src_format_type = GetFormatType(src.info.format);
     if (src_format_type == dst_format_type) {
@@ -1639,10 +1663,21 @@ std::pair<FramebufferId, ImageViewId> TextureCache<P>::RenderTargetFromImage(
     ImageId image_id, const ImageViewInfo& view_info) {
     const ImageViewId view_id = FindOrEmplaceImageView(image_id, view_info);
     const ImageBase& image = slot_images[image_id];
+    const bool is_rescaled = True(image.flags & ImageFlagBits::Rescaled);
     const bool is_color = GetFormatType(image.info.format) == SurfaceType::ColorTexture;
     const ImageViewId color_view_id = is_color ? view_id : ImageViewId{};
     const ImageViewId depth_view_id = is_color ? ImageViewId{} : view_id;
-    const Extent3D extent = MipSize(image.info.size, view_info.range.base.level);
+    Extent3D extent = MipSize(image.info.size, view_info.range.base.level);
+    if (is_rescaled) {
+        const auto& resolution = Settings::values.resolution_info;
+        const auto scale_up = [&](u32 value) {
+            return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
+        };
+        extent.width = scale_up(extent.width);
+        if (image.info.type == ImageType::e2D) {
+            extent.height = scale_up(extent.height);
+        }
+    }
     const u32 num_samples = image.info.num_samples;
     const auto [samples_x, samples_y] = SamplesLog2(num_samples);
     const FramebufferId framebuffer_id = GetFramebufferId(RenderTargets{
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 1f51fcee8..deddf0d30 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -316,7 +316,7 @@ private:
     void PrepareImageView(ImageViewId image_view_id, bool is_modification, bool invalidate);
 
     /// Execute copies from one image to the other, even if they are incompatible
-    void CopyImage(ImageId dst_id, ImageId src_id, std::span<const ImageCopy> copies);
+    void CopyImage(ImageId dst_id, ImageId src_id, std::vector<ImageCopy> copies);
 
     /// Bind an image view as render target, downloading resources preemtively if needed
     void BindRenderTarget(ImageViewId* old_id, ImageViewId new_id);
-- 
cgit v1.2.3


From dfc65cd0a3b259588b47db1d32c827e7fc071aeb Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Wed, 21 Jul 2021 10:15:09 +0200
Subject: Texture Cache: Implement Rescaling on Aliases and Blits.

---
 src/video_core/texture_cache/texture_cache.h | 58 +++++++++++++++++++++++++---
 1 file changed, 53 insertions(+), 5 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 df697cdeb..25fea8240 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -437,8 +437,32 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     PrepareImage(src_id, false, false);
     PrepareImage(dst_id, true, false);
 
-    ImageBase& dst_image = slot_images[dst_id];
-    const ImageBase& src_image = slot_images[src_id];
+    Image& dst_image = slot_images[dst_id];
+    const Image& src_image = slot_images[src_id];
+
+    const bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
+    bool is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
+
+    if (is_src_rescaled && !is_dst_rescaled) {
+        if (ImageCanRescale(dst_image)) {
+            is_dst_rescaled = dst_image.ScaleUp();
+        }
+    }
+
+    const auto& resolution = Settings::values.resolution_info;
+    const auto scale_up = [&](u32 value) -> u32 {
+        if (value == 0) {
+            return 0U;
+        }
+        return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
+    };
+
+    const auto scale_region = [&](Region2D& region) {
+        region.start.x = scale_up(region.start.x);
+        region.start.y = scale_up(region.start.y);
+        region.end.x = scale_up(region.end.x);
+        region.end.y = scale_up(region.end.y);
+    };
 
     // TODO: Deduplicate
     const std::optional src_base = src_image.TryFindBase(src.Address());
@@ -446,20 +470,26 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     const ImageViewInfo src_view_info(ImageViewType::e2D, images.src_format, src_range);
     const auto [src_framebuffer_id, src_view_id] = RenderTargetFromImage(src_id, src_view_info);
     const auto [src_samples_x, src_samples_y] = SamplesLog2(src_image.info.num_samples);
-    const Region2D src_region{
+    Region2D src_region{
         Offset2D{.x = copy.src_x0 >> src_samples_x, .y = copy.src_y0 >> src_samples_y},
         Offset2D{.x = copy.src_x1 >> src_samples_x, .y = copy.src_y1 >> src_samples_y},
     };
+    if (is_src_rescaled) {
+        scale_region(src_region);
+    }
 
     const std::optional dst_base = dst_image.TryFindBase(dst.Address());
     const SubresourceRange dst_range{.base = dst_base.value(), .extent = {1, 1}};
     const ImageViewInfo dst_view_info(ImageViewType::e2D, images.dst_format, dst_range);
     const auto [dst_framebuffer_id, dst_view_id] = RenderTargetFromImage(dst_id, dst_view_info);
     const auto [dst_samples_x, dst_samples_y] = SamplesLog2(dst_image.info.num_samples);
-    const Region2D dst_region{
+    Region2D dst_region{
         Offset2D{.x = copy.dst_x0 >> dst_samples_x, .y = copy.dst_y0 >> dst_samples_y},
         Offset2D{.x = copy.dst_x1 >> dst_samples_x, .y = copy.dst_y1 >> dst_samples_y},
     };
+    if (is_dst_rescaled) {
+        scale_region(dst_region);
+    }
 
     // Always call this after src_framebuffer_id was queried, as the address might be invalidated.
     Framebuffer* const dst_framebuffer = &slot_framebuffers[dst_framebuffer_id];
@@ -1514,18 +1544,28 @@ void TextureCache<P>::MarkModification(ImageBase& image) noexcept {
 template <class P>
 void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
     boost::container::small_vector<const AliasedImage*, 1> aliased_images;
-    ImageBase& image = slot_images[image_id];
+    Image& image = slot_images[image_id];
+    bool any_rescaled = True(image.flags & ImageFlagBits::Rescaled);
     u64 most_recent_tick = image.modification_tick;
     for (const AliasedImage& aliased : image.aliased_images) {
         ImageBase& aliased_image = slot_images[aliased.id];
         if (image.modification_tick < aliased_image.modification_tick) {
             most_recent_tick = std::max(most_recent_tick, aliased_image.modification_tick);
             aliased_images.push_back(&aliased);
+            any_rescaled |= True(image.flags & ImageFlagBits::Rescaled);
         }
     }
     if (aliased_images.empty()) {
         return;
     }
+    const bool can_rescale = ImageCanRescale(image);
+    if (any_rescaled) {
+        if (can_rescale) {
+            ScaleUp(image);
+        } else {
+            ScaleDown(image);
+        }
+    }
     image.modification_tick = most_recent_tick;
     std::ranges::sort(aliased_images, [this](const AliasedImage* lhs, const AliasedImage* rhs) {
         const ImageBase& lhs_image = slot_images[lhs->id];
@@ -1533,6 +1573,14 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
         return lhs_image.modification_tick < rhs_image.modification_tick;
     });
     for (const AliasedImage* const aliased : aliased_images) {
+        if (any_rescaled) {
+            Image& aliased_image = slot_images[aliased->id];
+            if (can_rescale) {
+                ScaleUp(aliased_image);
+            } else {
+                ScaleDown(aliased_image);
+            }
+        }
         CopyImage(image_id, aliased->id, aliased->copies);
     }
 }
-- 
cgit v1.2.3


From d5143c83a9eacf23cc66616bcd1a1b0ccfda5082 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Thu, 22 Jul 2021 00:16:19 -0400
Subject: texture_cache: Fix typo in aliased image rescaling

---
 src/video_core/texture_cache/texture_cache.h | 2 +-
 1 file changed, 1 insertion(+), 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 25fea8240..179f37526 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1552,7 +1552,7 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
         if (image.modification_tick < aliased_image.modification_tick) {
             most_recent_tick = std::max(most_recent_tick, aliased_image.modification_tick);
             aliased_images.push_back(&aliased);
-            any_rescaled |= True(image.flags & ImageFlagBits::Rescaled);
+            any_rescaled |= True(aliased_image.flags & ImageFlagBits::Rescaled);
         }
     }
     if (aliased_images.empty()) {
-- 
cgit v1.2.3


From 74efa57c1b78b4a07ad0003e847bd5f0aa7c7bb5 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp
Date: Sun, 25 Jul 2021 21:44:13 -0300
Subject: texture_cache: Add image getters

---
 src/video_core/texture_cache/texture_cache.h      | 10 ++++++++++
 src/video_core/texture_cache/texture_cache_base.h |  6 ++++++
 2 files changed, 16 insertions(+)

(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 179f37526..ae74a6ecf 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -119,6 +119,16 @@ typename P::ImageView& TextureCache<P>::GetImageView(ImageViewId id) noexcept {
     return slot_image_views[id];
 }
 
+template <class P>
+const typename P::Image& TextureCache<P>::GetImage(ImageId id) const noexcept {
+    return slot_images[id];
+}
+
+template <class P>
+typename P::Image& TextureCache<P>::GetImage(ImageId id) noexcept {
+    return slot_images[id];
+}
+
 template <class P>
 void TextureCache<P>::MarkModification(ImageId id) noexcept {
     MarkModification(slot_images[id]);
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index deddf0d30..0d2d9ec2e 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -95,6 +95,12 @@ public:
     /// Return a reference to the given image view id
     [[nodiscard]] ImageView& GetImageView(ImageViewId id) noexcept;
 
+    /// Return a constant reference to the given image id
+    [[nodiscard]] const Image& GetImage(ImageId id) const noexcept;
+
+    /// Return a reference to the given image id
+    [[nodiscard]] Image& GetImage(ImageId id) noexcept;
+
     /// Mark an image as modified from the GPU
     void MarkModification(ImageId id) noexcept;
 
-- 
cgit v1.2.3


From 0e8cf38f392f2ea6f7f5195070ad721b78590c04 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 26 Jul 2021 09:33:00 +0200
Subject: Texture Cache: Implement Blacklisting.

---
 src/video_core/texture_cache/image_base.h         |  1 +
 src/video_core/texture_cache/texture_cache.h      | 34 ++++++++++++++++++++++-
 src/video_core/texture_cache/texture_cache_base.h |  2 ++
 3 files changed, 36 insertions(+), 1 deletion(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 1cd30fd37..10dd52e28 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -37,6 +37,7 @@ enum class ImageFlagBits : u32 {
     // Rescaler
     Rescaled = 1 << 12,
     RescaleChecked = 1 << 13,
+    Blacklisted = 1 << 14,
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index ae74a6ecf..ce5994d5f 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -227,6 +227,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         flags[Dirty::RenderTargetControl] = false;
 
         bool can_rescale = true;
+        bool any_blacklisted = false;
         std::array<ImageId, NUM_RT> tmp_color_images{};
         ImageId tmp_depth_image{};
         const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
@@ -236,6 +237,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                 id_save = image_id;
                 auto& image = slot_images[image_id];
                 can_rescale &= ImageCanRescale(image);
+                any_blacklisted |= True(image.flags & ImageFlagBits::Blacklisted);
             } else {
                 id_save = CORRUPT_ID;
             }
@@ -268,10 +270,13 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
             scale_up(tmp_depth_image);
         } else {
             rescaled = false;
-            const auto scale_down = [this](ImageId image_id) {
+            const auto scale_down = [this, any_blacklisted](ImageId image_id) {
                 if (image_id != CORRUPT_ID) {
                     Image& image = slot_images[image_id];
                     ScaleDown(image);
+                    if (any_blacklisted) {
+                        image.flags |= ImageFlagBits::Blacklisted;
+                    }
                 }
             };
             for (size_t index = 0; index < NUM_RT; ++index) {
@@ -736,8 +741,22 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
     return image_id;
 }
 
+template <class P>
+bool TextureCache<P>::BlackListImage(ImageId image_id) {
+    auto& image = slot_images[image_id];
+    if (True(image.flags & ImageFlagBits::Blacklisted)) {
+        return false;
+    }
+    image.flags |= ImageFlagBits::Blacklisted;
+    ScaleDown(image);
+    return true;
+}
+
 template <class P>
 bool TextureCache<P>::ImageCanRescale(Image& image) {
+    if (True(image.flags & ImageFlagBits::Blacklisted)) {
+        return false;
+    }
     if (True(image.flags & ImageFlagBits::Rescaled) ||
         True(image.flags & ImageFlagBits::RescaleChecked)) {
         return true;
@@ -912,6 +931,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     bool can_rescale =
         (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
     bool any_rescaled = false;
+    bool any_blacklisted = false;
     for (const ImageId sibling_id : all_siblings) {
         if (!can_rescale) {
             break;
@@ -919,6 +939,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         Image& sibling = slot_images[sibling_id];
         can_rescale &= ImageCanRescale(sibling);
         any_rescaled |= True(sibling.flags & ImageFlagBits::Rescaled);
+        any_blacklisted |= True(sibling.flags & ImageFlagBits::Blacklisted);
     }
 
     can_rescale &= any_rescaled;
@@ -932,6 +953,9 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
             ScaleDown(sibling);
+            if (any_blacklisted) {
+                sibling.flags |= ImageFlagBits::Blacklisted;
+            }
         }
     }
 
@@ -1556,6 +1580,7 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
     boost::container::small_vector<const AliasedImage*, 1> aliased_images;
     Image& image = slot_images[image_id];
     bool any_rescaled = True(image.flags & ImageFlagBits::Rescaled);
+    bool any_blacklisted = True(image.flags & ImageFlagBits::Blacklisted);
     u64 most_recent_tick = image.modification_tick;
     for (const AliasedImage& aliased : image.aliased_images) {
         ImageBase& aliased_image = slot_images[aliased.id];
@@ -1563,6 +1588,7 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
             most_recent_tick = std::max(most_recent_tick, aliased_image.modification_tick);
             aliased_images.push_back(&aliased);
             any_rescaled |= True(aliased_image.flags & ImageFlagBits::Rescaled);
+            any_blacklisted |= True(aliased_image.flags & ImageFlagBits::Blacklisted);
         }
     }
     if (aliased_images.empty()) {
@@ -1574,6 +1600,9 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
             ScaleUp(image);
         } else {
             ScaleDown(image);
+            if (any_blacklisted) {
+                image.flags |= ImageFlagBits::Blacklisted;
+            }
         }
     }
     image.modification_tick = most_recent_tick;
@@ -1589,6 +1618,9 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
                 ScaleUp(aliased_image);
             } else {
                 ScaleDown(aliased_image);
+                if (any_blacklisted) {
+                    aliased_image.flags |= ImageFlagBits::Blacklisted;
+                }
             }
         }
         CopyImage(image_id, aliased->id, aliased->copies);
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 0d2d9ec2e..35a29cd9b 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -176,6 +176,8 @@ public:
 
     [[nodiscard]] bool IsRescaling();
 
+    [[nodiscard]] bool BlackListImage(ImageId image_id);
+
     std::mutex mutex;
 
 private:
-- 
cgit v1.2.3


From 07c564f38b238af9be7a9d8aee1149a353c2880b Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Tue, 27 Jul 2021 01:29:55 +0200
Subject: Texture Cache: Implement Rating System.

---
 src/video_core/texture_cache/image_base.cpp  |  6 ++--
 src/video_core/texture_cache/image_base.h    |  2 ++
 src/video_core/texture_cache/image_info.cpp  | 11 ++++++++
 src/video_core/texture_cache/image_info.h    |  1 +
 src/video_core/texture_cache/texture_cache.h | 42 ++++++++++++++++++++--------
 5 files changed, 47 insertions(+), 15 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index 6052d148a..e9e725edf 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -60,9 +60,9 @@ namespace {
 ImageBase::ImageBase(const ImageInfo& info_, GPUVAddr gpu_addr_, VAddr cpu_addr_)
     : info{info_}, guest_size_bytes{CalculateGuestSizeInBytes(info)},
       unswizzled_size_bytes{CalculateUnswizzledSizeBytes(info)},
-      converted_size_bytes{CalculateConvertedSizeBytes(info)}, gpu_addr{gpu_addr_},
-      cpu_addr{cpu_addr_}, cpu_addr_end{cpu_addr + guest_size_bytes},
-      mip_level_offsets{CalculateMipLevelOffsets(info)} {
+      converted_size_bytes{CalculateConvertedSizeBytes(info)}, scale_rating{},
+      scale_tick{}, gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_},
+      cpu_addr_end{cpu_addr + guest_size_bytes}, mip_level_offsets{CalculateMipLevelOffsets(info)} {
     if (info.type == ImageType::e3D) {
         slice_offsets = CalculateSliceOffsets(info);
         slice_subresources = CalculateSliceSubresources(info);
diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 10dd52e28..97f107b4d 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -78,6 +78,8 @@ struct ImageBase {
     u32 guest_size_bytes = 0;
     u32 unswizzled_size_bytes = 0;
     u32 converted_size_bytes = 0;
+    u32 scale_rating = 0;
+    u64 scale_tick = 0;
     ImageFlagBits flags = ImageFlagBits::CpuModified;
 
     GPUVAddr gpu_addr = 0;
diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index 022ca9033..7fa8fd4fe 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -31,6 +31,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
             .depth = config.block_depth,
         };
     }
+    rescaleable = false;
     tile_width_spacing = config.tile_width_spacing;
     if (config.texture_type != TextureType::Texture2D &&
         config.texture_type != TextureType::Texture2DNoMipmap) {
@@ -53,12 +54,14 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
     case TextureType::Texture2DNoMipmap:
         ASSERT(config.Depth() == 1);
         type = config.IsPitchLinear() ? ImageType::Linear : ImageType::e2D;
+        rescaleable = !config.IsPitchLinear();
         size.width = config.Width();
         size.height = config.Height();
         resources.layers = config.BaseLayer() + 1;
         break;
     case TextureType::Texture2DArray:
         type = ImageType::e2D;
+        rescaleable = true;
         size.width = config.Width();
         size.height = config.Height();
         resources.layers = config.BaseLayer() + config.Depth();
@@ -98,12 +101,14 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         // FIXME: Call this without passing *this
         layer_stride = CalculateLayerStride(*this);
         maybe_unaligned_layer_stride = CalculateLayerSize(*this);
+        rescaleable &= (block.depth == 0) && resources.levels == 1;
     }
 }
 
 ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index) noexcept {
     const auto& rt = regs.rt[index];
     format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(rt.format);
+    rescaleable = false;
     if (rt.tile_mode.is_pitch_linear) {
         ASSERT(rt.tile_mode.is_3d == 0);
         type = ImageType::Linear;
@@ -129,6 +134,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         type = ImageType::e3D;
         size.depth = rt.depth;
     } else {
+        rescaleable = block.depth == 0 && size.height > 256;
         type = ImageType::e2D;
         resources.layers = rt.depth;
     }
@@ -138,6 +144,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept {
     format = VideoCore::Surface::PixelFormatFromDepthFormat(regs.zeta.format);
     size.width = regs.zeta_width;
     size.height = regs.zeta_height;
+    rescaleable = false;
     resources.levels = 1;
     layer_stride = regs.zeta.layer_stride * 4;
     maybe_unaligned_layer_stride = layer_stride;
@@ -156,6 +163,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept {
         type = ImageType::e3D;
         size.depth = regs.zeta_depth;
     } else {
+        rescaleable = block.depth == 0 && size.height > 256;
         type = ImageType::e2D;
         resources.layers = regs.zeta_depth;
     }
@@ -164,6 +172,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept {
 ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
     UNIMPLEMENTED_IF_MSG(config.layer != 0, "Surface layer is not zero");
     format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(config.format);
+    rescaleable = false;
     if (config.linear == Tegra::Engines::Fermi2D::MemoryLayout::Pitch) {
         type = ImageType::Linear;
         size = Extent3D{
@@ -174,6 +183,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
         pitch = config.pitch;
     } else {
         type = config.block_depth > 0 ? ImageType::e3D : ImageType::e2D;
+
         block = Extent3D{
             .width = config.block_width,
             .height = config.block_height,
@@ -186,6 +196,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
             .height = config.height,
             .depth = 1,
         };
+        rescaleable = block.depth == 0 && size.height > 256;
     }
 }
 
diff --git a/src/video_core/texture_cache/image_info.h b/src/video_core/texture_cache/image_info.h
index 16d4cee37..e874d2870 100644
--- a/src/video_core/texture_cache/image_info.h
+++ b/src/video_core/texture_cache/image_info.h
@@ -33,6 +33,7 @@ struct ImageInfo {
     u32 maybe_unaligned_layer_stride = 0;
     u32 num_samples = 1;
     u32 tile_width_spacing = 0;
+    bool rescaleable = false;
 };
 
 } // namespace VideoCommon
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index ce5994d5f..be40f6b88 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -216,7 +216,10 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         return;
     }
 
+    u32 scale_rating;
     bool rescaled;
+    std::array<ImageId, NUM_RT> tmp_color_images{};
+    ImageId tmp_depth_image{};
     do {
         flags[Dirty::RenderTargets] = false;
 
@@ -226,10 +229,10 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         const bool force = flags[Dirty::RenderTargetControl];
         flags[Dirty::RenderTargetControl] = false;
 
+        scale_rating = 0;
+        bool any_rescaled = false;
         bool can_rescale = true;
         bool any_blacklisted = false;
-        std::array<ImageId, NUM_RT> tmp_color_images{};
-        ImageId tmp_depth_image{};
         const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
             if (view_id) {
                 const auto& view = slot_image_views[view_id];
@@ -238,6 +241,10 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                 auto& image = slot_images[image_id];
                 can_rescale &= ImageCanRescale(image);
                 any_blacklisted |= True(image.flags & ImageFlagBits::Blacklisted);
+                any_rescaled |= True(image.flags & ImageFlagBits::Rescaled);
+                scale_rating = std::max<u32>(scale_rating, image.scale_tick <= frame_tick
+                                                               ? image.scale_rating + 1U
+                                                               : image.scale_rating);
             } else {
                 id_save = CORRUPT_ID;
             }
@@ -257,17 +264,19 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
 
         if (can_rescale) {
-            rescaled = true;
+            rescaled = any_rescaled || scale_rating >= 2;
             const auto scale_up = [this](ImageId image_id) {
                 if (image_id != CORRUPT_ID) {
                     Image& image = slot_images[image_id];
                     ScaleUp(image);
                 }
             };
-            for (size_t index = 0; index < NUM_RT; ++index) {
-                scale_up(tmp_color_images[index]);
+            if (rescaled) {
+                for (size_t index = 0; index < NUM_RT; ++index) {
+                    scale_up(tmp_color_images[index]);
+                }
+                scale_up(tmp_depth_image);
             }
-            scale_up(tmp_depth_image);
         } else {
             rescaled = false;
             const auto scale_down = [this, any_blacklisted](ImageId image_id) {
@@ -283,10 +292,23 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                 scale_down(tmp_color_images[index]);
             }
             scale_down(tmp_depth_image);
+            scale_rating = 0;
         }
     } while (has_deleted_images);
     // Rescale End
 
+    const auto set_rating = [this, scale_rating](ImageId image_id) {
+        if (image_id != CORRUPT_ID) {
+            Image& image = slot_images[image_id];
+            image.scale_rating = scale_rating;
+            image.scale_tick = frame_tick + 1;
+        }
+    };
+    for (size_t index = 0; index < NUM_RT; ++index) {
+        set_rating(tmp_color_images[index]);
+    }
+    set_rating(tmp_depth_image);
+
     if (is_rescaling != rescaled) {
         flags[Dirty::RescaleViewports] = true;
         flags[Dirty::RescaleScissors] = true;
@@ -761,10 +783,7 @@ bool TextureCache<P>::ImageCanRescale(Image& image) {
         True(image.flags & ImageFlagBits::RescaleChecked)) {
         return true;
     }
-    const auto& info = image.info;
-    const bool can_this_rescale =
-        (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
-    if (!can_this_rescale) {
+    if (!image.info.rescaleable) {
         image.flags &= ~ImageFlagBits::RescaleChecked;
         return false;
     }
@@ -928,8 +947,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     };
     ForEachSparseImageInRegion(gpu_addr, size_bytes, region_check_gpu);
 
-    bool can_rescale =
-        (info.type == ImageType::e1D || info.type == ImageType::e2D) && info.block.depth == 0;
+    bool can_rescale = info.rescaleable;
     bool any_rescaled = false;
     bool any_blacklisted = false;
     for (const ImageId sibling_id : all_siblings) {
-- 
cgit v1.2.3


From 56ccda1d9952368d0c1e29d7c4b486c547de9549 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp
Date: Wed, 28 Jul 2021 02:47:06 -0300
Subject: texture_cache: Simplify image view queries and blacklisting

---
 src/video_core/texture_cache/image_base.cpp       |  2 +
 src/video_core/texture_cache/image_base.h         |  3 ++
 src/video_core/texture_cache/image_view_base.cpp  |  2 +-
 src/video_core/texture_cache/image_view_base.h    |  4 +-
 src/video_core/texture_cache/texture_cache.h      | 47 +++++++++++++----------
 src/video_core/texture_cache/texture_cache_base.h | 30 +++++++++------
 src/video_core/texture_cache/types.h              |  7 ++++
 7 files changed, 60 insertions(+), 35 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index e9e725edf..25a211df8 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -69,6 +69,8 @@ ImageBase::ImageBase(const ImageInfo& info_, GPUVAddr gpu_addr_, VAddr cpu_addr_
     }
 }
 
+ImageBase::ImageBase(const NullImageParams&) {}
+
 ImageMapView::ImageMapView(GPUVAddr gpu_addr_, VAddr cpu_addr_, size_t size_, ImageId image_id_)
     : gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_}, size{size_}, image_id{image_id_} {}
 
diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 97f107b4d..9c34687e0 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -48,8 +48,11 @@ struct AliasedImage {
     ImageId id;
 };
 
+struct NullImageParams {};
+
 struct ImageBase {
     explicit ImageBase(const ImageInfo& info, GPUVAddr gpu_addr, VAddr cpu_addr);
+    explicit ImageBase(const NullImageParams&);
 
     [[nodiscard]] std::optional<SubresourceBase> TryFindBase(GPUVAddr other_addr) const noexcept;
 
diff --git a/src/video_core/texture_cache/image_view_base.cpp b/src/video_core/texture_cache/image_view_base.cpp
index 450becbeb..e66dc9320 100644
--- a/src/video_core/texture_cache/image_view_base.cpp
+++ b/src/video_core/texture_cache/image_view_base.cpp
@@ -45,6 +45,6 @@ ImageViewBase::ImageViewBase(const ImageInfo& info, const ImageViewInfo& view_in
     ASSERT_MSG(view_info.type == ImageViewType::Buffer, "Expected texture buffer");
 }
 
-ImageViewBase::ImageViewBase(const NullImageParams&) {}
+ImageViewBase::ImageViewBase(const NullImageViewParams&) : image_id{NULL_IMAGE_ID} {}
 
 } // namespace VideoCommon
diff --git a/src/video_core/texture_cache/image_view_base.h b/src/video_core/texture_cache/image_view_base.h
index 903f715c5..9c24c5359 100644
--- a/src/video_core/texture_cache/image_view_base.h
+++ b/src/video_core/texture_cache/image_view_base.h
@@ -15,7 +15,7 @@ using VideoCore::Surface::PixelFormat;
 struct ImageViewInfo;
 struct ImageInfo;
 
-struct NullImageParams {};
+struct NullImageViewParams {};
 
 enum class ImageViewFlagBits : u16 {
     PreemtiveDownload = 1 << 0,
@@ -28,7 +28,7 @@ struct ImageViewBase {
     explicit ImageViewBase(const ImageViewInfo& info, const ImageInfo& image_info,
                            ImageId image_id);
     explicit ImageViewBase(const ImageInfo& info, const ImageViewInfo& view_info);
-    explicit ImageViewBase(const NullImageParams&);
+    explicit ImageViewBase(const NullImageViewParams&);
 
     [[nodiscard]] bool IsBuffer() const noexcept {
         return type == ImageViewType::Buffer;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index be40f6b88..4e97a9e6a 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -36,7 +36,6 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
                               Tegra::MemoryManager& gpu_memory_)
     : runtime{runtime_}, rasterizer{rasterizer_}, maxwell3d{maxwell3d_},
       kepler_compute{kepler_compute_}, gpu_memory{gpu_memory_} {
-    runtime.Init();
     // Configure null sampler
     TSCEntry sampler_descriptor{};
     sampler_descriptor.min_filter.Assign(Tegra::Texture::TextureFilter::Linear);
@@ -46,7 +45,8 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
 
     // Make sure the first index is reserved for the null resources
     // This way the null resource becomes a compile time constant
-    void(slot_image_views.insert(runtime, NullImageParams{}));
+    void(slot_images.insert(NullImageParams{}));
+    void(slot_image_views.insert(runtime, NullImageViewParams{}));
     void(slot_samplers.insert(runtime, sampler_descriptor));
 
     if constexpr (HAS_DEVICE_MEMORY_INFO) {
@@ -57,7 +57,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
         critical_memory = std::max(possible_critical_memory, DEFAULT_CRITICAL_MEMORY);
         minimum_memory = 0;
     } else {
-        // on OGL we can be more conservatives as the driver takes care.
+        // On OpenGL we can be more conservatives as the driver takes care.
         expected_memory = DEFAULT_EXPECTED_MEMORY + 512_MiB;
         critical_memory = DEFAULT_CRITICAL_MEMORY + 1_GiB;
         minimum_memory = expected_memory;
@@ -135,15 +135,14 @@ void TextureCache<P>::MarkModification(ImageId id) noexcept {
 }
 
 template <class P>
-void TextureCache<P>::FillGraphicsImageViews(std::span<const u32> indices,
-                                             std::span<ImageViewId> image_view_ids) {
-    FillImageViews(graphics_image_table, graphics_image_view_ids, indices, image_view_ids);
+template <bool has_blacklists>
+void TextureCache<P>::FillGraphicsImageViews(std::span<ImageViewInOut> views) {
+    FillImageViews<has_blacklists>(graphics_image_table, graphics_image_view_ids, views);
 }
 
 template <class P>
-void TextureCache<P>::FillComputeImageViews(std::span<const u32> indices,
-                                            std::span<ImageViewId> image_view_ids) {
-    FillImageViews(compute_image_table, compute_image_view_ids, indices, image_view_ids);
+void TextureCache<P>::FillComputeImageViews(std::span<ImageViewInOut> views) {
+    FillImageViews<false>(compute_image_table, compute_image_view_ids, views);
 }
 
 template <class P>
@@ -346,17 +345,26 @@ typename P::Framebuffer* TextureCache<P>::GetFramebuffer() {
 }
 
 template <class P>
+template <bool has_blacklists>
 void TextureCache<P>::FillImageViews(DescriptorTable<TICEntry>& table,
                                      std::span<ImageViewId> cached_image_view_ids,
-                                     std::span<const u32> indices,
-                                     std::span<ImageViewId> image_view_ids) {
-    ASSERT(indices.size() <= image_view_ids.size());
+                                     std::span<ImageViewInOut> views) {
+    bool has_blacklisted;
     do {
         has_deleted_images = false;
-        std::ranges::transform(indices, image_view_ids.begin(), [&](u32 index) {
-            return VisitImageView(table, cached_image_view_ids, index);
-        });
-    } while (has_deleted_images);
+        if constexpr (has_blacklists) {
+            has_blacklisted = false;
+        }
+        for (ImageViewInOut& view : views) {
+            view.id = VisitImageView(table, cached_image_view_ids, view.index);
+            if constexpr (has_blacklists) {
+                if (view.blacklist && view.id != NULL_IMAGE_VIEW_ID) {
+                    const ImageViewBase& image_view{slot_image_views[view.id]};
+                    has_blacklisted |= BlackListImage(image_view.image_id);
+                }
+            }
+        }
+    } while (has_deleted_images || (has_blacklists && has_blacklisted));
 }
 
 template <class P>
@@ -622,7 +630,7 @@ void TextureCache<P>::PopAsyncFlushes() {
 }
 
 template <class P>
-bool TextureCache<P>::IsRescaling() {
+bool TextureCache<P>::IsRescaling() const noexcept {
     return is_rescaling;
 }
 
@@ -775,12 +783,11 @@ bool TextureCache<P>::BlackListImage(ImageId image_id) {
 }
 
 template <class P>
-bool TextureCache<P>::ImageCanRescale(Image& image) {
+bool TextureCache<P>::ImageCanRescale(ImageBase& image) {
     if (True(image.flags & ImageFlagBits::Blacklisted)) {
         return false;
     }
-    if (True(image.flags & ImageFlagBits::Rescaled) ||
-        True(image.flags & ImageFlagBits::RescaleChecked)) {
+    if (True(image.flags & (ImageFlagBits::Rescaled | ImageFlagBits::RescaleChecked))) {
         return true;
     }
     if (!image.info.rescaleable) {
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 35a29cd9b..b6cc09682 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -39,6 +39,16 @@ using VideoCore::Surface::PixelFormatFromDepthFormat;
 using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
 using namespace Common::Literals;
 
+struct ImageViewInOut {
+    u32 index;
+    bool blacklist;
+    union {
+        struct Empty {
+        } empty{};
+        ImageViewId id;
+    };
+};
+
 template <class P>
 class TextureCache {
     /// Address shift for caching images into a hash table
@@ -53,11 +63,6 @@ class TextureCache {
     /// 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;
 
-    /// Image view ID for null descriptors
-    static constexpr ImageViewId NULL_IMAGE_VIEW_ID{0};
-    /// Sampler ID for bugged sampler ids
-    static constexpr SamplerId NULL_SAMPLER_ID{0};
-
     static constexpr u64 DEFAULT_EXPECTED_MEMORY = 1_GiB;
     static constexpr u64 DEFAULT_CRITICAL_MEMORY = 2_GiB;
 
@@ -105,11 +110,11 @@ public:
     void MarkModification(ImageId id) noexcept;
 
     /// Fill image_view_ids with the graphics images in indices
-    void FillGraphicsImageViews(std::span<const u32> indices,
-                                std::span<ImageViewId> image_view_ids);
+    template <bool has_blacklists>
+    void FillGraphicsImageViews(std::span<ImageViewInOut> views);
 
     /// Fill image_view_ids with the compute images in indices
-    void FillComputeImageViews(std::span<const u32> indices, std::span<ImageViewId> image_view_ids);
+    void FillComputeImageViews(std::span<ImageViewInOut> views);
 
     /// Get the sampler from the graphics descriptor table in the specified index
     Sampler* GetGraphicsSampler(u32 index);
@@ -174,7 +179,7 @@ public:
     /// Return true when a CPU region is modified from the GPU
     [[nodiscard]] bool IsRegionGpuModified(VAddr addr, size_t size);
 
-    [[nodiscard]] bool IsRescaling();
+    [[nodiscard]] bool IsRescaling() const noexcept;
 
     [[nodiscard]] bool BlackListImage(ImageId image_id);
 
@@ -216,9 +221,10 @@ private:
     void RunGarbageCollector();
 
     /// Fills image_view_ids in the image views in indices
+    template <bool has_blacklists>
     void FillImageViews(DescriptorTable<TICEntry>& table,
-                        std::span<ImageViewId> cached_image_view_ids, std::span<const u32> indices,
-                        std::span<ImageViewId> image_view_ids);
+                        std::span<ImageViewId> cached_image_view_ids,
+                        std::span<ImageViewInOut> views);
 
     /// Find or create an image view in the guest descriptor table
     ImageViewId VisitImageView(DescriptorTable<TICEntry>& table,
@@ -336,7 +342,7 @@ private:
     /// Returns true if the current clear parameters clear the whole image of a given image view
     [[nodiscard]] bool IsFullClear(ImageViewId id);
 
-    bool ImageCanRescale(Image& image);
+    bool ImageCanRescale(ImageBase& image);
     void InvalidateScale(Image& image);
     bool ScaleUp(Image& image);
     bool ScaleDown(Image& image);
diff --git a/src/video_core/texture_cache/types.h b/src/video_core/texture_cache/types.h
index 47a11cb2f..5c274abdf 100644
--- a/src/video_core/texture_cache/types.h
+++ b/src/video_core/texture_cache/types.h
@@ -22,6 +22,13 @@ using ImageAllocId = SlotId;
 using SamplerId = SlotId;
 using FramebufferId = SlotId;
 
+/// Fake image ID for null image views
+constexpr ImageId NULL_IMAGE_ID{0};
+/// Image view ID for null descriptors
+constexpr ImageViewId NULL_IMAGE_VIEW_ID{0};
+/// Sampler ID for bugged sampler ids
+constexpr SamplerId NULL_SAMPLER_ID{0};
+
 enum class ImageType : u32 {
     e1D,
     e2D,
-- 
cgit v1.2.3


From 2182d2575010a5a85c99c09c6a1c57962242444d Mon Sep 17 00:00:00 2001
From: ReinUsesLisp
Date: Wed, 28 Jul 2021 02:53:24 -0300
Subject: texture_cache: Fix blacklists on compute

---
 src/video_core/texture_cache/texture_cache.h | 2 +-
 1 file changed, 1 insertion(+), 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 4e97a9e6a..4dbded635 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -142,7 +142,7 @@ void TextureCache<P>::FillGraphicsImageViews(std::span<ImageViewInOut> views) {
 
 template <class P>
 void TextureCache<P>::FillComputeImageViews(std::span<ImageViewInOut> views) {
-    FillImageViews<false>(compute_image_table, compute_image_view_ids, views);
+    FillImageViews<true>(compute_image_table, compute_image_view_ids, views);
 }
 
 template <class P>
-- 
cgit v1.2.3


From c7a1cbad44487b2c5f9da31ce6d3c76b7dec4f05 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp
Date: Sat, 31 Jul 2021 17:42:37 -0300
Subject: texture_cache: Add getter to query if image view is rescaled

---
 src/video_core/texture_cache/texture_cache.h      | 16 ++++++----------
 src/video_core/texture_cache/texture_cache_base.h |  9 +++------
 2 files changed, 9 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 4dbded635..0e70c4db2 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -119,16 +119,6 @@ typename P::ImageView& TextureCache<P>::GetImageView(ImageViewId id) noexcept {
     return slot_image_views[id];
 }
 
-template <class P>
-const typename P::Image& TextureCache<P>::GetImage(ImageId id) const noexcept {
-    return slot_images[id];
-}
-
-template <class P>
-typename P::Image& TextureCache<P>::GetImage(ImageId id) noexcept {
-    return slot_images[id];
-}
-
 template <class P>
 void TextureCache<P>::MarkModification(ImageId id) noexcept {
     MarkModification(slot_images[id]);
@@ -634,6 +624,12 @@ bool TextureCache<P>::IsRescaling() const noexcept {
     return is_rescaling;
 }
 
+template <class P>
+bool TextureCache<P>::IsRescaling(const ImageViewBase& image_view) const noexcept {
+    const ImageBase& image = slot_images[image_view.image_id];
+    return True(image.flags & ImageFlagBits::Rescaled);
+}
+
 template <class P>
 bool TextureCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
     bool is_modified = false;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index b6cc09682..8b417b611 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -21,6 +21,7 @@
 #include "video_core/texture_cache/descriptor_table.h"
 #include "video_core/texture_cache/image_base.h"
 #include "video_core/texture_cache/image_info.h"
+#include "video_core/texture_cache/image_view_base.h"
 #include "video_core/texture_cache/image_view_info.h"
 #include "video_core/texture_cache/render_targets.h"
 #include "video_core/texture_cache/slot_vector.h"
@@ -100,12 +101,6 @@ public:
     /// Return a reference to the given image view id
     [[nodiscard]] ImageView& GetImageView(ImageViewId id) noexcept;
 
-    /// Return a constant reference to the given image id
-    [[nodiscard]] const Image& GetImage(ImageId id) const noexcept;
-
-    /// Return a reference to the given image id
-    [[nodiscard]] Image& GetImage(ImageId id) noexcept;
-
     /// Mark an image as modified from the GPU
     void MarkModification(ImageId id) noexcept;
 
@@ -181,6 +176,8 @@ public:
 
     [[nodiscard]] bool IsRescaling() const noexcept;
 
+    [[nodiscard]] bool IsRescaling(const ImageViewBase& image_view) const noexcept;
+
     [[nodiscard]] bool BlackListImage(ImageId image_id);
 
     std::mutex mutex;
-- 
cgit v1.2.3


From ed675cfd8cc89d64c763becfd991d1dd40deac5a Mon Sep 17 00:00:00 2001
From: ameerj
Date: Wed, 4 Aug 2021 19:02:30 -0400
Subject: texture_cache: Disable dst_image scaling in BlitImage

Fixes scaling in Super Mario Party
---
 src/video_core/texture_cache/texture_cache.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 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 0e70c4db2..d86f80b5d 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -478,11 +478,13 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     const bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
     bool is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
 
-    if (is_src_rescaled && !is_dst_rescaled) {
-        if (ImageCanRescale(dst_image)) {
-            is_dst_rescaled = dst_image.ScaleUp();
-        }
-    }
+    // TODO: This requires the rendertarget image views to be updated with the upscaled sizes,
+    // otherwise the blit will use a larger framebuffer size than the image view attachment.
+    // if (is_src_rescaled && !is_dst_rescaled) {
+    //     if (ImageCanRescale(dst_image)) {
+    //         is_dst_rescaled = dst_image.ScaleUp();
+    //     }
+    // }
 
     const auto& resolution = Settings::values.resolution_info;
     const auto scale_up = [&](u32 value) -> u32 {
-- 
cgit v1.2.3


From 4b1393a691d1d8d79c57e7b73734cb8287b91760 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sat, 7 Aug 2021 02:15:24 +0200
Subject: Texture Cache: Correctly fix Blits Rescaling.

---
 src/video_core/texture_cache/texture_cache.h | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 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 d86f80b5d..2de439889 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -473,18 +473,21 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     PrepareImage(dst_id, true, false);
 
     Image& dst_image = slot_images[dst_id];
-    const Image& src_image = slot_images[src_id];
+    Image& src_image = slot_images[src_id];
 
-    const bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
+    bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
     bool is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
 
-    // TODO: This requires the rendertarget image views to be updated with the upscaled sizes,
-    // otherwise the blit will use a larger framebuffer size than the image view attachment.
-    // if (is_src_rescaled && !is_dst_rescaled) {
-    //     if (ImageCanRescale(dst_image)) {
-    //         is_dst_rescaled = dst_image.ScaleUp();
-    //     }
-    // }
+    if (is_src_rescaled != is_dst_rescaled) {
+        if (ImageCanRescale(dst_image)) {
+            ScaleUp(dst_image);
+            is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
+        }
+        if (ImageCanRescale(src_image)) {
+            ScaleUp(src_image);
+            is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
+        }
+    }
 
     const auto& resolution = Settings::values.resolution_info;
     const auto scale_up = [&](u32 value) -> u32 {
-- 
cgit v1.2.3


From d7c97921696486a95aaaf5c805b9fcc12230de77 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sat, 7 Aug 2021 04:32:17 +0200
Subject: TextureCache: Fix Buffer Views Scaling.

---
 src/video_core/texture_cache/image_view_base.cpp | 11 ++++++-----
 src/video_core/texture_cache/texture_cache.h     |  3 +++
 2 files changed, 9 insertions(+), 5 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_view_base.cpp b/src/video_core/texture_cache/image_view_base.cpp
index e66dc9320..c7b4fc231 100644
--- a/src/video_core/texture_cache/image_view_base.cpp
+++ b/src/video_core/texture_cache/image_view_base.cpp
@@ -37,11 +37,12 @@ ImageViewBase::ImageViewBase(const ImageViewInfo& info, const ImageInfo& image_i
 }
 
 ImageViewBase::ImageViewBase(const ImageInfo& info, const ImageViewInfo& view_info)
-    : format{info.format}, type{ImageViewType::Buffer}, size{
-                                                            .width = info.size.width,
-                                                            .height = 1,
-                                                            .depth = 1,
-                                                        } {
+    : image_id{NULL_IMAGE_ID}, format{info.format}, type{ImageViewType::Buffer},
+      size{
+          .width = info.size.width,
+          .height = 1,
+          .depth = 1,
+      } {
     ASSERT_MSG(view_info.type == ImageViewType::Buffer, "Expected texture buffer");
 }
 
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 2de439889..764984546 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -631,6 +631,9 @@ bool TextureCache<P>::IsRescaling() const noexcept {
 
 template <class P>
 bool TextureCache<P>::IsRescaling(const ImageViewBase& image_view) const noexcept {
+    if (image_view.type == ImageViewType::Buffer) {
+        return false;
+    }
     const ImageBase& image = slot_images[image_view.image_id];
     return True(image.flags & ImageFlagBits::Rescaled);
 }
-- 
cgit v1.2.3


From 68e038404cc0069d9f59068a60b56e67b4321e7a Mon Sep 17 00:00:00 2001
From: ameerj
Date: Sat, 14 Aug 2021 00:01:47 -0400
Subject: shader, video_core: Fix GCC build errors

---
 src/video_core/texture_cache/texture_cache_base.h | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 8b417b611..517a4c224 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -41,13 +41,9 @@ using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
 using namespace Common::Literals;
 
 struct ImageViewInOut {
-    u32 index;
-    bool blacklist;
-    union {
-        struct Empty {
-        } empty{};
-        ImageViewId id;
-    };
+    u32 index{};
+    bool blacklist{};
+    ImageViewId id{};
 };
 
 template <class P>
-- 
cgit v1.2.3


From 6000fe69a4b2805a48ce045d9a383fda27d5e57b Mon Sep 17 00:00:00 2001
From: ameerj
Date: Tue, 14 Sep 2021 00:45:50 -0400
Subject: image_info: Mark MSAA textures as non-rescalable

Blitting or resolving multisampled images requires the dimensions of the src and dst to be equal for valid usage, making them difficult for resolution scaling using the current implementation.
---
 src/video_core/texture_cache/image_info.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index 7fa8fd4fe..bdf306bf9 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -101,7 +101,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         // FIXME: Call this without passing *this
         layer_stride = CalculateLayerStride(*this);
         maybe_unaligned_layer_stride = CalculateLayerSize(*this);
-        rescaleable &= (block.depth == 0) && resources.levels == 1;
+        rescaleable &= (block.depth == 0) && resources.levels == 1 && num_samples == 1;
     }
 }
 
@@ -134,7 +134,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         type = ImageType::e3D;
         size.depth = rt.depth;
     } else {
-        rescaleable = block.depth == 0 && size.height > 256;
+        rescaleable = block.depth == 0 && size.height > 256 && num_samples == 1;
         type = ImageType::e2D;
         resources.layers = rt.depth;
     }
-- 
cgit v1.2.3


From 19ca0c9ab5cbaa86e30743ea760e0aab5c40c1d6 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 20 Sep 2021 19:11:03 +0200
Subject: TextureCache: Base fixes on rescaling.

---
 src/video_core/texture_cache/texture_cache.h | 7 ++++---
 1 file changed, 4 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 764984546..a543776fd 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -205,8 +205,8 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         return;
     }
 
-    u32 scale_rating;
-    bool rescaled;
+    u32 scale_rating = 0;
+    bool rescaled = false;
     std::array<ImageId, NUM_RT> tmp_color_images{};
     ImageId tmp_depth_image{};
     do {
@@ -223,7 +223,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         bool can_rescale = true;
         bool any_blacklisted = false;
         const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
-            if (view_id) {
+            if (view_id != NULL_IMAGE_VIEW_ID && view_id != ImageViewId{}) {
                 const auto& view = slot_image_views[view_id];
                 const auto image_id = view.image_id;
                 id_save = image_id;
@@ -265,6 +265,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                     scale_up(tmp_color_images[index]);
                 }
                 scale_up(tmp_depth_image);
+                scale_rating = 2;
             }
         } else {
             rescaled = false;
-- 
cgit v1.2.3


From ea82bd4b7e4c4f23a40f8a35858d8b74950fc347 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 20 Sep 2021 22:18:15 +0200
Subject: Texture Cache: Fix Rescaling on Multisample

---
 src/video_core/texture_cache/image_info.cpp  |  4 ++--
 src/video_core/texture_cache/texture_cache.h | 17 +++++++++++++----
 2 files changed, 15 insertions(+), 6 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index bdf306bf9..7fa8fd4fe 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -101,7 +101,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         // FIXME: Call this without passing *this
         layer_stride = CalculateLayerStride(*this);
         maybe_unaligned_layer_stride = CalculateLayerSize(*this);
-        rescaleable &= (block.depth == 0) && resources.levels == 1 && num_samples == 1;
+        rescaleable &= (block.depth == 0) && resources.levels == 1;
     }
 }
 
@@ -134,7 +134,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         type = ImageType::e3D;
         size.depth = rt.depth;
     } else {
-        rescaleable = block.depth == 0 && size.height > 256 && num_samples == 1;
+        rescaleable = block.depth == 0 && size.height > 256;
         type = ImageType::e2D;
         resources.layers = rt.depth;
     }
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index a543776fd..b60f840c1 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -476,17 +476,26 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     Image& dst_image = slot_images[dst_id];
     Image& src_image = slot_images[src_id];
 
+    bool is_resolve = src_image.info.num_samples != 1 && dst_image.info.num_samples == 1;
+
     bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
     bool is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
 
     if (is_src_rescaled != is_dst_rescaled) {
-        if (ImageCanRescale(dst_image)) {
-            ScaleUp(dst_image);
-            is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
-        }
         if (ImageCanRescale(src_image)) {
             ScaleUp(src_image);
             is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
+            if (is_resolve) {
+                dst_image.info.rescaleable = true;
+                for (const auto& alias : dst_image.aliased_images) {
+                    Image& other_image = slot_images[alias.id];
+                    other_image.info.rescaleable = true;
+                }
+            }
+        }
+        if (ImageCanRescale(dst_image)) {
+            ScaleUp(dst_image);
+            is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
         }
     }
 
-- 
cgit v1.2.3


From 237a43004fb27a273495a0b44515cf7389dea553 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sun, 3 Oct 2021 22:42:29 +0200
Subject: Texture Cache: Fix calculations when scaling.

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

(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 b60f840c1..691198853 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -858,6 +858,12 @@ bool TextureCache<P>::ScaleUp(Image& image) {
     if (!rescaled) {
         return false;
     }
+    const auto& add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
+    const auto sign = std::signbit(add_to_size);
+    const u64 tentative_size = static_cast<u64>(
+        std::max(image.guest_size_bytes, image.unswizzled_size_bytes) * std::abs(add_to_size));
+    const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
+    total_used_memory += sign ? -fitted_size : fitted_size;
     InvalidateScale(image);
     return true;
 }
@@ -868,6 +874,12 @@ bool TextureCache<P>::ScaleDown(Image& image) {
     if (!rescaled) {
         return false;
     }
+    const auto& add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
+    const auto sign = std::signbit(add_to_size);
+    const u64 tentative_size = static_cast<u64>(
+        std::max(image.guest_size_bytes, image.unswizzled_size_bytes) * std::abs(add_to_size));
+    const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
+    total_used_memory += sign ? fitted_size : -fitted_size;
     InvalidateScale(image);
     return true;
 }
-- 
cgit v1.2.3


From 88ef04dbaf26ab83ec85bfa3c68434c283c66e50 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Tue, 5 Oct 2021 00:07:51 -0400
Subject: texture_cache: Refactor scaled image size calculation

---
 src/video_core/texture_cache/texture_cache.h      | 24 +++++++++++------------
 src/video_core/texture_cache/texture_cache_base.h |  1 +
 2 files changed, 13 insertions(+), 12 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 691198853..b708e41b5 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -852,18 +852,23 @@ void TextureCache<P>::InvalidateScale(Image& image) {
     has_deleted_images = true;
 }
 
+template <class P>
+u64 TextureCache<P>::GetScaledImageSizeBytes(Image& image) {
+    const f32 add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
+    const bool sign = std::signbit(add_to_size);
+    const u32 image_size_bytes = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
+    const u64 tentative_size = static_cast<u64>(image_size_bytes * std::abs(add_to_size));
+    const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
+    return sign ? -fitted_size : fitted_size;
+}
+
 template <class P>
 bool TextureCache<P>::ScaleUp(Image& image) {
     const bool rescaled = image.ScaleUp();
     if (!rescaled) {
         return false;
     }
-    const auto& add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
-    const auto sign = std::signbit(add_to_size);
-    const u64 tentative_size = static_cast<u64>(
-        std::max(image.guest_size_bytes, image.unswizzled_size_bytes) * std::abs(add_to_size));
-    const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
-    total_used_memory += sign ? -fitted_size : fitted_size;
+    total_used_memory += GetScaledImageSizeBytes(image);
     InvalidateScale(image);
     return true;
 }
@@ -874,12 +879,7 @@ bool TextureCache<P>::ScaleDown(Image& image) {
     if (!rescaled) {
         return false;
     }
-    const auto& add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
-    const auto sign = std::signbit(add_to_size);
-    const u64 tentative_size = static_cast<u64>(
-        std::max(image.guest_size_bytes, image.unswizzled_size_bytes) * std::abs(add_to_size));
-    const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
-    total_used_memory += sign ? fitted_size : -fitted_size;
+    total_used_memory += GetScaledImageSizeBytes(image);
     InvalidateScale(image);
     return true;
 }
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 517a4c224..40e003b60 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -339,6 +339,7 @@ private:
     void InvalidateScale(Image& image);
     bool ScaleUp(Image& image);
     bool ScaleDown(Image& image);
+    u64 GetScaledImageSizeBytes(Image& image);
 
     Runtime& runtime;
     VideoCore::RasterizerInterface& rasterizer;
-- 
cgit v1.2.3


From 31478c6c1b841b9a820742830b136775fafe270f Mon Sep 17 00:00:00 2001
From: ameerj
Date: Wed, 6 Oct 2021 01:18:00 -0400
Subject: video_core: Misc resolution scaling related refactoring

---
 src/video_core/texture_cache/texture_cache.h | 2 --
 1 file changed, 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 b708e41b5..630c73005 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1726,9 +1726,7 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
         };
         for (auto& copy : copies) {
             copy.src_offset.x = scale_up(copy.src_offset.x);
-
             copy.dst_offset.x = scale_up(copy.dst_offset.x);
-
             copy.extent.width = scale_up(copy.extent.width);
             if (both_2d) {
                 copy.src_offset.y = scale_up(copy.src_offset.y);
-- 
cgit v1.2.3


From f8339cd703c2e6d24477be211e1fd91a6e1ef334 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Wed, 6 Oct 2021 02:02:05 -0400
Subject: vk_texture_cache: Fix early returns on unsupported scales

---
 src/video_core/texture_cache/texture_cache.h | 2 +-
 1 file changed, 1 insertion(+), 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 630c73005..de522cc43 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -857,7 +857,7 @@ u64 TextureCache<P>::GetScaledImageSizeBytes(Image& image) {
     const f32 add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
     const bool sign = std::signbit(add_to_size);
     const u32 image_size_bytes = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
-    const u64 tentative_size = static_cast<u64>(image_size_bytes * std::abs(add_to_size));
+    const u64 tentative_size = image_size_bytes * static_cast<u32>(std::abs(add_to_size));
     const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
     return sign ? -fitted_size : fitted_size;
 }
-- 
cgit v1.2.3


From b14f2c7c826b8bbea02c1f2674ab024a5ae0695e Mon Sep 17 00:00:00 2001
From: ameerj
Date: Mon, 11 Oct 2021 23:55:53 -0400
Subject: texture_cache: Fix image resolves when src/dst are not both scaled

---
 src/video_core/texture_cache/texture_cache.h | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 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 de522cc43..38895c2e9 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -475,12 +475,10 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
 
     Image& dst_image = slot_images[dst_id];
     Image& src_image = slot_images[src_id];
-
-    bool is_resolve = src_image.info.num_samples != 1 && dst_image.info.num_samples == 1;
-
     bool is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
     bool is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
 
+    const bool is_resolve = src_image.info.num_samples != 1 && dst_image.info.num_samples == 1;
     if (is_src_rescaled != is_dst_rescaled) {
         if (ImageCanRescale(src_image)) {
             ScaleUp(src_image);
@@ -498,7 +496,13 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
             is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
         }
     }
-
+    if (is_resolve && (is_src_rescaled != is_dst_rescaled)) {
+        // A resolve requires both images to be the same dimensions. Resize down if needed.
+        ScaleDown(src_image);
+        ScaleDown(dst_image);
+        is_src_rescaled = True(src_image.flags & ImageFlagBits::Rescaled);
+        is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
+    }
     const auto& resolution = Settings::values.resolution_info;
     const auto scale_up = [&](u32 value) -> u32 {
         if (value == 0) {
@@ -506,7 +510,6 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
         }
         return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
     };
-
     const auto scale_region = [&](Region2D& region) {
         region.start.x = scale_up(region.start.x);
         region.start.y = scale_up(region.start.y);
-- 
cgit v1.2.3


From abd07e41582b6d8f7efdedb936cdd7a7fddf9912 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Tue, 12 Oct 2021 00:35:01 -0400
Subject: video_core: Refactor resolution scale function

---
 src/video_core/texture_cache/texture_cache.h | 39 +++++++++-------------------
 1 file changed, 12 insertions(+), 27 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 38895c2e9..c77332b46 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -504,17 +504,11 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
         is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
     }
     const auto& resolution = Settings::values.resolution_info;
-    const auto scale_up = [&](u32 value) -> u32 {
-        if (value == 0) {
-            return 0U;
-        }
-        return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
-    };
     const auto scale_region = [&](Region2D& region) {
-        region.start.x = scale_up(region.start.x);
-        region.start.y = scale_up(region.start.y);
-        region.end.x = scale_up(region.end.x);
-        region.end.y = scale_up(region.end.y);
+        region.start.x = resolution.ScaleUp(region.start.x);
+        region.start.y = resolution.ScaleUp(region.start.y);
+        region.end.x = resolution.ScaleUp(region.end.x);
+        region.end.y = resolution.ScaleUp(region.end.y);
     };
 
     // TODO: Deduplicate
@@ -1721,20 +1715,14 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
         ASSERT(True(dst.flags & ImageFlagBits::Rescaled));
         const bool both_2d{src.info.type == ImageType::e2D && dst.info.type == ImageType::e2D};
         const auto& resolution = Settings::values.resolution_info;
-        const auto scale_up = [&](u32 value) -> u32 {
-            if (value == 0) {
-                return 0U;
-            }
-            return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
-        };
         for (auto& copy : copies) {
-            copy.src_offset.x = scale_up(copy.src_offset.x);
-            copy.dst_offset.x = scale_up(copy.dst_offset.x);
-            copy.extent.width = scale_up(copy.extent.width);
+            copy.src_offset.x = resolution.ScaleUp(copy.src_offset.x);
+            copy.dst_offset.x = resolution.ScaleUp(copy.dst_offset.x);
+            copy.extent.width = resolution.ScaleUp(copy.extent.width);
             if (both_2d) {
-                copy.src_offset.y = scale_up(copy.src_offset.y);
-                copy.dst_offset.y = scale_up(copy.dst_offset.y);
-                copy.extent.height = scale_up(copy.extent.height);
+                copy.src_offset.y = resolution.ScaleUp(copy.src_offset.y);
+                copy.dst_offset.y = resolution.ScaleUp(copy.dst_offset.y);
+                copy.extent.height = resolution.ScaleUp(copy.extent.height);
             }
         }
     }
@@ -1812,12 +1800,9 @@ std::pair<FramebufferId, ImageViewId> TextureCache<P>::RenderTargetFromImage(
     Extent3D extent = MipSize(image.info.size, view_info.range.base.level);
     if (is_rescaled) {
         const auto& resolution = Settings::values.resolution_info;
-        const auto scale_up = [&](u32 value) {
-            return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
-        };
-        extent.width = scale_up(extent.width);
+        extent.width = resolution.ScaleUp(extent.width);
         if (image.info.type == ImageType::e2D) {
-            extent.height = scale_up(extent.height);
+            extent.height = resolution.ScaleUp(extent.height);
         }
     }
     const u32 num_samples = image.info.num_samples;
-- 
cgit v1.2.3


From 4de584005fe8ae00608f8c3267a78e7cf0eb52aa Mon Sep 17 00:00:00 2001
From: ameerj
Date: Tue, 12 Oct 2021 01:45:54 -0400
Subject: texture_cache: Fix infinitely recursive ImageCanRescale check

---
 src/video_core/texture_cache/image_base.cpp  |  2 ++
 src/video_core/texture_cache/image_base.h    |  5 +++--
 src/video_core/texture_cache/texture_cache.h | 16 ++++++++--------
 3 files changed, 13 insertions(+), 10 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index 25a211df8..1909c9ecb 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -256,6 +256,8 @@ void AddImageAlias(ImageBase& lhs, ImageBase& rhs, ImageId lhs_id, ImageId rhs_i
     }
     lhs.aliased_images.push_back(std::move(lhs_alias));
     rhs.aliased_images.push_back(std::move(rhs_alias));
+    lhs.flags &= ~ImageFlagBits::IsRescalable;
+    rhs.flags &= ~ImageFlagBits::IsRescalable;
 }
 
 } // namespace VideoCommon
diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 9c34687e0..bab290ac7 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -36,8 +36,9 @@ enum class ImageFlagBits : u32 {
 
     // Rescaler
     Rescaled = 1 << 12,
-    RescaleChecked = 1 << 13,
-    Blacklisted = 1 << 14,
+    CheckingRescalable = 1 << 13,
+    IsRescalable = 1 << 14,
+    Blacklisted = 1 << 15,
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index c77332b46..c1fb12679 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -795,25 +795,25 @@ bool TextureCache<P>::BlackListImage(ImageId image_id) {
 
 template <class P>
 bool TextureCache<P>::ImageCanRescale(ImageBase& image) {
-    if (True(image.flags & ImageFlagBits::Blacklisted)) {
+    if (!image.info.rescaleable || True(image.flags & ImageFlagBits::Blacklisted)) {
         return false;
     }
-    if (True(image.flags & (ImageFlagBits::Rescaled | ImageFlagBits::RescaleChecked))) {
+    if (True(image.flags & (ImageFlagBits::Rescaled | ImageFlagBits::CheckingRescalable))) {
         return true;
     }
-    if (!image.info.rescaleable) {
-        image.flags &= ~ImageFlagBits::RescaleChecked;
-        return false;
+    if (True(image.flags & ImageFlagBits::IsRescalable)) {
+        return true;
     }
-    image.flags |= ImageFlagBits::RescaleChecked;
+    image.flags |= ImageFlagBits::CheckingRescalable;
     for (const auto& alias : image.aliased_images) {
         Image& other_image = slot_images[alias.id];
         if (!ImageCanRescale(other_image)) {
-            image.flags &= ~ImageFlagBits::RescaleChecked;
+            image.flags &= ~ImageFlagBits::CheckingRescalable;
             return false;
         }
     }
-    image.flags &= ~ImageFlagBits::RescaleChecked;
+    image.flags &= ~ImageFlagBits::CheckingRescalable;
+    image.flags |= ImageFlagBits::IsRescalable;
     return true;
 }
 
-- 
cgit v1.2.3


From 0f14c9379eae9c3caf8f4b932eace0a84d728f94 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Thu, 14 Oct 2021 14:12:25 -0400
Subject: texture_cache_base: Remove unused function declarations

---
 src/video_core/texture_cache/texture_cache_base.h | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 40e003b60..4dbe050af 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -144,14 +144,6 @@ public:
                    const Tegra::Engines::Fermi2D::Surface& src,
                    const Tegra::Engines::Fermi2D::Config& copy);
 
-    /// Invalidate the contents of the color buffer index
-    /// These contents become unspecified, the cache can assume aggressive optimizations.
-    void InvalidateColorBuffer(size_t index);
-
-    /// Invalidate the contents of the depth buffer
-    /// These contents become unspecified, the cache can assume aggressive optimizations.
-    void InvalidateDepthBuffer();
-
     /// Try to find a cached image view in the given CPU address
     [[nodiscard]] ImageView* TryFindFramebufferImageView(VAddr cpu_addr);
 
-- 
cgit v1.2.3


From b7ccc58f235d9e442677eb10259b7196a387c6bc Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Fri, 15 Oct 2021 22:59:16 +0200
Subject: Texture Cahe: Fix downscaling on SMO.

---
 src/video_core/texture_cache/image_info.cpp  | 4 ++++
 src/video_core/texture_cache/image_info.h    | 1 +
 src/video_core/texture_cache/texture_cache.h | 3 +++
 3 files changed, 8 insertions(+)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index 7fa8fd4fe..d8e414247 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -102,6 +102,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         layer_stride = CalculateLayerStride(*this);
         maybe_unaligned_layer_stride = CalculateLayerSize(*this);
         rescaleable &= (block.depth == 0) && resources.levels == 1;
+        downscaleable = size.height > 512;
     }
 }
 
@@ -135,6 +136,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         size.depth = rt.depth;
     } else {
         rescaleable = block.depth == 0 && size.height > 256;
+        downscaleable = size.height > 512;
         type = ImageType::e2D;
         resources.layers = rt.depth;
     }
@@ -164,6 +166,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept {
         size.depth = regs.zeta_depth;
     } else {
         rescaleable = block.depth == 0 && size.height > 256;
+        downscaleable = size.height > 512;
         type = ImageType::e2D;
         resources.layers = regs.zeta_depth;
     }
@@ -197,6 +200,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
             .depth = 1,
         };
         rescaleable = block.depth == 0 && size.height > 256;
+        downscaleable = size.height > 512;
     }
 }
 
diff --git a/src/video_core/texture_cache/image_info.h b/src/video_core/texture_cache/image_info.h
index e874d2870..5932dcaba 100644
--- a/src/video_core/texture_cache/image_info.h
+++ b/src/video_core/texture_cache/image_info.h
@@ -34,6 +34,7 @@ struct ImageInfo {
     u32 num_samples = 1;
     u32 tile_width_spacing = 0;
     bool rescaleable = false;
+    bool downscaleable = false;
 };
 
 } // namespace VideoCommon
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index c1fb12679..261cb6c48 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -798,6 +798,9 @@ bool TextureCache<P>::ImageCanRescale(ImageBase& image) {
     if (!image.info.rescaleable || True(image.flags & ImageFlagBits::Blacklisted)) {
         return false;
     }
+    if (Settings::values.resolution_info.downscale && !image.info.downscaleable) {
+        return false;
+    }
     if (True(image.flags & (ImageFlagBits::Rescaled | ImageFlagBits::CheckingRescalable))) {
         return true;
     }
-- 
cgit v1.2.3


From ef1dc4263586f5b81b53a5158db2c1cd2086ed4c Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sun, 17 Oct 2021 01:22:13 +0200
Subject: Texture cache: Fix memory consumption and ignore rating when a depth
 texture is rendered.

---
 src/video_core/texture_cache/texture_cache.h | 7 ++++---
 1 file changed, 4 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 261cb6c48..c06cddae9 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -230,7 +230,8 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                 auto& image = slot_images[image_id];
                 can_rescale &= ImageCanRescale(image);
                 any_blacklisted |= True(image.flags & ImageFlagBits::Blacklisted);
-                any_rescaled |= True(image.flags & ImageFlagBits::Rescaled);
+                any_rescaled |= True(image.flags & ImageFlagBits::Rescaled) ||
+                                GetFormatType(image.info.format) != SurfaceType::ColorTexture;
                 scale_rating = std::max<u32>(scale_rating, image.scale_tick <= frame_tick
                                                                ? image.scale_rating + 1U
                                                                : image.scale_rating);
@@ -857,7 +858,7 @@ u64 TextureCache<P>::GetScaledImageSizeBytes(Image& image) {
     const f32 add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
     const bool sign = std::signbit(add_to_size);
     const u32 image_size_bytes = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
-    const u64 tentative_size = image_size_bytes * static_cast<u32>(std::abs(add_to_size));
+    const u64 tentative_size = image_size_bytes * static_cast<u64>(std::abs(add_to_size));
     const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
     return sign ? -fitted_size : fitted_size;
 }
@@ -879,7 +880,7 @@ bool TextureCache<P>::ScaleDown(Image& image) {
     if (!rescaled) {
         return false;
     }
-    total_used_memory += GetScaledImageSizeBytes(image);
+    total_used_memory -= GetScaledImageSizeBytes(image);
     InvalidateScale(image);
     return true;
 }
-- 
cgit v1.2.3


From d4f5193bd308988a80f52941d9eefc4c857bfa99 Mon Sep 17 00:00:00 2001
From: FernandoS27
Date: Sun, 17 Oct 2021 02:21:26 +0200
Subject: Texture Cache: Rescale conversions between depth and color

---
 src/video_core/texture_cache/texture_cache.h | 2 +-
 1 file changed, 1 insertion(+), 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 c06cddae9..a035d2b18 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1774,7 +1774,7 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
         };
         UNIMPLEMENTED_IF(copy.extent != expected_size);
 
-        runtime.ConvertImage(dst_framebuffer, dst_view, src_view);
+        runtime.ConvertImage(dst_framebuffer, dst_view, src_view, is_rescaled);
     }
 }
 
-- 
cgit v1.2.3


From 425ab9ef4b982213f4ee0d53196f5474e255374f Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sun, 17 Oct 2021 18:01:18 +0200
Subject: Texture Cache: Fix downscaling and correct memory comsumption.

---
 src/video_core/texture_cache/image_base.cpp       |  4 +--
 src/video_core/texture_cache/image_base.h         |  5 ++++
 src/video_core/texture_cache/texture_cache.h      | 31 +++++++++++++++--------
 src/video_core/texture_cache/texture_cache_base.h |  2 +-
 4 files changed, 28 insertions(+), 14 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index 1909c9ecb..3db2ec825 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -60,8 +60,8 @@ namespace {
 ImageBase::ImageBase(const ImageInfo& info_, GPUVAddr gpu_addr_, VAddr cpu_addr_)
     : info{info_}, guest_size_bytes{CalculateGuestSizeInBytes(info)},
       unswizzled_size_bytes{CalculateUnswizzledSizeBytes(info)},
-      converted_size_bytes{CalculateConvertedSizeBytes(info)}, scale_rating{},
-      scale_tick{}, gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_},
+      converted_size_bytes{CalculateConvertedSizeBytes(info)}, scale_rating{}, scale_tick{},
+      scale_count{}, gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_},
       cpu_addr_end{cpu_addr + guest_size_bytes}, mip_level_offsets{CalculateMipLevelOffsets(info)} {
     if (info.type == ImageType::e3D) {
         slice_offsets = CalculateSliceOffsets(info);
diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index bab290ac7..cd4b5f636 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -77,6 +77,10 @@ struct ImageBase {
     void CheckBadOverlapState();
     void CheckAliasState();
 
+    bool HasScaled() {
+        return scale_count > 0;
+    }
+
     ImageInfo info;
 
     u32 guest_size_bytes = 0;
@@ -84,6 +88,7 @@ struct ImageBase {
     u32 converted_size_bytes = 0;
     u32 scale_rating = 0;
     u64 scale_tick = 0;
+    u32 scale_count = 0;
     ImageFlagBits flags = ImageFlagBits::CpuModified;
 
     GPUVAddr gpu_addr = 0;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index a035d2b18..cf0d33a45 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -854,8 +854,8 @@ void TextureCache<P>::InvalidateScale(Image& image) {
 }
 
 template <class P>
-u64 TextureCache<P>::GetScaledImageSizeBytes(Image& image) {
-    const f32 add_to_size = Settings::values.resolution_info.up_factor - 1.0f;
+u64 TextureCache<P>::GetScaledImageSizeBytes(ImageBase& image) {
+    const f32 add_to_size = Settings::values.resolution_info.up_factor;
     const bool sign = std::signbit(add_to_size);
     const u32 image_size_bytes = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
     const u64 tentative_size = image_size_bytes * static_cast<u64>(std::abs(add_to_size));
@@ -865,11 +865,14 @@ u64 TextureCache<P>::GetScaledImageSizeBytes(Image& image) {
 
 template <class P>
 bool TextureCache<P>::ScaleUp(Image& image) {
+    const bool has_copy = image.HasScaled();
     const bool rescaled = image.ScaleUp();
     if (!rescaled) {
         return false;
     }
-    total_used_memory += GetScaledImageSizeBytes(image);
+    if (!has_copy) {
+        total_used_memory += GetScaledImageSizeBytes(image);
+    }
     InvalidateScale(image);
     return true;
 }
@@ -880,7 +883,10 @@ bool TextureCache<P>::ScaleDown(Image& image) {
     if (!rescaled) {
         return false;
     }
-    total_used_memory -= GetScaledImageSizeBytes(image);
+    const bool has_copy = image.HasScaled();
+    if (!has_copy) {
+        total_used_memory -= GetScaledImageSizeBytes(image);
+    }
     InvalidateScale(image);
     return true;
 }
@@ -1391,13 +1397,6 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
                "Trying to unregister an already registered image");
     image.flags &= ~ImageFlagBits::Registered;
     image.flags &= ~ImageFlagBits::BadOverlap;
-    u64 tentative_size = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
-    if ((IsPixelFormatASTC(image.info.format) &&
-         True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
-        True(image.flags & ImageFlagBits::Converted)) {
-        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
-    }
-    total_used_memory -= Common::AlignUp(tentative_size, 1024);
     lru_cache.Free(image.lru_index);
     const auto& clear_page_table =
         [this, image_id](
@@ -1478,6 +1477,16 @@ template <class P>
 void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
+    if (image.HasScaled()) {
+        total_used_memory -= GetScaledImageSizeBytes(image);
+    }
+    u64 tentative_size = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
+    if ((IsPixelFormatASTC(image.info.format) &&
+         True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
+        True(image.flags & ImageFlagBits::Converted)) {
+        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
+    }
+    total_used_memory -= Common::AlignUp(tentative_size, 1024);
     if (False(image.flags & ImageFlagBits::Sparse)) {
         rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
         return;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 4dbe050af..e210393ba 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -331,7 +331,7 @@ private:
     void InvalidateScale(Image& image);
     bool ScaleUp(Image& image);
     bool ScaleDown(Image& image);
-    u64 GetScaledImageSizeBytes(Image& image);
+    u64 GetScaledImageSizeBytes(ImageBase& image);
 
     Runtime& runtime;
     VideoCore::RasterizerInterface& rasterizer;
-- 
cgit v1.2.3


From c2ca55c9d576940cfb37ba8569b1656b72c65569 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 18 Oct 2021 14:04:54 +0200
Subject: Texture Cache: ease the requirements of textures being blacklisted.

---
 src/video_core/texture_cache/texture_cache.h      | 27 ++++++-----------------
 src/video_core/texture_cache/texture_cache_base.h |  2 --
 2 files changed, 7 insertions(+), 22 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 cf0d33a45..c885586e8 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -221,7 +221,6 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         scale_rating = 0;
         bool any_rescaled = false;
         bool can_rescale = true;
-        bool any_blacklisted = false;
         const auto check_rescale = [&](ImageViewId view_id, ImageId& id_save) {
             if (view_id != NULL_IMAGE_VIEW_ID && view_id != ImageViewId{}) {
                 const auto& view = slot_image_views[view_id];
@@ -229,7 +228,6 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
                 id_save = image_id;
                 auto& image = slot_images[image_id];
                 can_rescale &= ImageCanRescale(image);
-                any_blacklisted |= True(image.flags & ImageFlagBits::Blacklisted);
                 any_rescaled |= True(image.flags & ImageFlagBits::Rescaled) ||
                                 GetFormatType(image.info.format) != SurfaceType::ColorTexture;
                 scale_rating = std::max<u32>(scale_rating, image.scale_tick <= frame_tick
@@ -270,20 +268,17 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
             }
         } else {
             rescaled = false;
-            const auto scale_down = [this, any_blacklisted](ImageId image_id) {
+            const auto scale_down = [this](ImageId image_id) {
                 if (image_id != CORRUPT_ID) {
                     Image& image = slot_images[image_id];
                     ScaleDown(image);
-                    if (any_blacklisted) {
-                        image.flags |= ImageFlagBits::Blacklisted;
-                    }
                 }
             };
             for (size_t index = 0; index < NUM_RT; ++index) {
                 scale_down(tmp_color_images[index]);
             }
             scale_down(tmp_depth_image);
-            scale_rating = 0;
+            scale_rating = 1;
         }
     } while (has_deleted_images);
     // Rescale End
@@ -352,7 +347,10 @@ void TextureCache<P>::FillImageViews(DescriptorTable<TICEntry>& table,
             if constexpr (has_blacklists) {
                 if (view.blacklist && view.id != NULL_IMAGE_VIEW_ID) {
                     const ImageViewBase& image_view{slot_image_views[view.id]};
-                    has_blacklisted |= BlackListImage(image_view.image_id);
+                    auto& image = slot_images[image_view.image_id];
+                    image.flags |= ImageFlagBits::Blacklisted;
+                    has_blacklisted |= ScaleDown(image);
+                    image.scale_rating = 0;
                 }
             }
         }
@@ -783,20 +781,9 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
     return image_id;
 }
 
-template <class P>
-bool TextureCache<P>::BlackListImage(ImageId image_id) {
-    auto& image = slot_images[image_id];
-    if (True(image.flags & ImageFlagBits::Blacklisted)) {
-        return false;
-    }
-    image.flags |= ImageFlagBits::Blacklisted;
-    ScaleDown(image);
-    return true;
-}
-
 template <class P>
 bool TextureCache<P>::ImageCanRescale(ImageBase& image) {
-    if (!image.info.rescaleable || True(image.flags & ImageFlagBits::Blacklisted)) {
+    if (!image.info.rescaleable) {
         return false;
     }
     if (Settings::values.resolution_info.downscale && !image.info.downscaleable) {
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index e210393ba..4f876b2f4 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -166,8 +166,6 @@ public:
 
     [[nodiscard]] bool IsRescaling(const ImageViewBase& image_view) const noexcept;
 
-    [[nodiscard]] bool BlackListImage(ImageId image_id);
-
     std::mutex mutex;
 
 private:
-- 
cgit v1.2.3


From 3b61de74e6dc7526ffa8f03c21d81e2c3566ce90 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Mon, 18 Oct 2021 22:56:36 +0200
Subject: Texture Cache: fix memory managment and optimize scaled downloads,
 uploads.

---
 src/video_core/texture_cache/image_base.cpp  |  2 +-
 src/video_core/texture_cache/image_base.h    |  6 +++---
 src/video_core/texture_cache/texture_cache.h | 22 +++++++++++-----------
 3 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index 3db2ec825..3db2fdf34 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -61,7 +61,7 @@ ImageBase::ImageBase(const ImageInfo& info_, GPUVAddr gpu_addr_, VAddr cpu_addr_
     : info{info_}, guest_size_bytes{CalculateGuestSizeInBytes(info)},
       unswizzled_size_bytes{CalculateUnswizzledSizeBytes(info)},
       converted_size_bytes{CalculateConvertedSizeBytes(info)}, scale_rating{}, scale_tick{},
-      scale_count{}, gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_},
+      has_scaled{}, gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_},
       cpu_addr_end{cpu_addr + guest_size_bytes}, mip_level_offsets{CalculateMipLevelOffsets(info)} {
     if (info.type == ImageType::e3D) {
         slice_offsets = CalculateSliceOffsets(info);
diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index cd4b5f636..02c669766 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -77,8 +77,8 @@ struct ImageBase {
     void CheckBadOverlapState();
     void CheckAliasState();
 
-    bool HasScaled() {
-        return scale_count > 0;
+    bool HasScaled() const {
+        return has_scaled;
     }
 
     ImageInfo info;
@@ -88,7 +88,7 @@ struct ImageBase {
     u32 converted_size_bytes = 0;
     u32 scale_rating = 0;
     u64 scale_tick = 0;
-    u32 scale_count = 0;
+    bool has_scaled = false;
     ImageFlagBits flags = ImageFlagBits::CpuModified;
 
     GPUVAddr gpu_addr = 0;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index c885586e8..13914dc8b 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -60,7 +60,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
         // On OpenGL we can be more conservatives as the driver takes care.
         expected_memory = DEFAULT_EXPECTED_MEMORY + 512_MiB;
         critical_memory = DEFAULT_CRITICAL_MEMORY + 1_GiB;
-        minimum_memory = expected_memory;
+        minimum_memory = 0;
     }
 }
 
@@ -1464,16 +1464,6 @@ template <class P>
 void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
-    if (image.HasScaled()) {
-        total_used_memory -= GetScaledImageSizeBytes(image);
-    }
-    u64 tentative_size = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
-    if ((IsPixelFormatASTC(image.info.format) &&
-         True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
-        True(image.flags & ImageFlagBits::Converted)) {
-        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
-    }
-    total_used_memory -= Common::AlignUp(tentative_size, 1024);
     if (False(image.flags & ImageFlagBits::Sparse)) {
         rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
         return;
@@ -1519,6 +1509,16 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
 template <class P>
 void TextureCache<P>::DeleteImage(ImageId image_id) {
     ImageBase& image = slot_images[image_id];
+    if (image.HasScaled()) {
+        total_used_memory -= GetScaledImageSizeBytes(image);
+    }
+    u64 tentative_size = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
+    if ((IsPixelFormatASTC(image.info.format) &&
+         True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
+        True(image.flags & ImageFlagBits::Converted)) {
+        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
+    }
+    total_used_memory -= Common::AlignUp(tentative_size, 1024);
     const GPUVAddr gpu_addr = image.gpu_addr;
     const auto alloc_it = image_allocs_table.find(gpu_addr);
     if (alloc_it == image_allocs_table.end()) {
-- 
cgit v1.2.3


From d37d10e7a7b9037a259b27923716e5ce3084d6c3 Mon Sep 17 00:00:00 2001
From: FernandoS27
Date: Wed, 20 Oct 2021 18:27:25 +0200
Subject: TextureCache: fix rescaling in aliases and overlap joins.

---
 src/video_core/texture_cache/texture_cache.h | 41 ++++++++++++++++++++--------
 src/video_core/texture_cache/util.cpp        |  8 ++++--
 src/video_core/texture_cache/util.h          |  3 +-
 3 files changed, 38 insertions(+), 14 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 13914dc8b..a32c11d04 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1037,8 +1037,11 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         if (overlap.info.num_samples != new_image.info.num_samples) {
             LOG_WARNING(HW_GPU, "Copying between images with different samples is not implemented");
         } else {
+            const auto& resolution = Settings::values.resolution_info;
             const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
-            auto copies = MakeShrinkImageCopies(new_info, overlap.info, base);
+            const u32 up_scale = can_rescale ? resolution.up_scale : 1;
+            const u32 down_shift = can_rescale ? resolution.down_shift : 0;
+            auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
             runtime.CopyImage(new_image, overlap, std::move(copies));
         }
         if (True(overlap.flags & ImageFlagBits::Tracked)) {
@@ -1659,19 +1662,35 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
         const ImageBase& rhs_image = slot_images[rhs->id];
         return lhs_image.modification_tick < rhs_image.modification_tick;
     });
+    const auto& resolution = Settings::values.resolution_info;
     for (const AliasedImage* const aliased : aliased_images) {
-        if (any_rescaled) {
-            Image& aliased_image = slot_images[aliased->id];
-            if (can_rescale) {
-                ScaleUp(aliased_image);
-            } else {
-                ScaleDown(aliased_image);
-                if (any_blacklisted) {
-                    aliased_image.flags |= ImageFlagBits::Blacklisted;
-                }
+        if (!resolution.active | !any_rescaled) {
+            CopyImage(image_id, aliased->id, aliased->copies);
+            continue;
+        }
+        Image& aliased_image = slot_images[aliased->id];
+        if (!can_rescale) {
+            ScaleDown(aliased_image);
+            if (any_blacklisted) {
+                aliased_image.flags |= ImageFlagBits::Blacklisted;
+            }
+            CopyImage(image_id, aliased->id, aliased->copies);
+            continue;
+        }
+        ScaleUp(aliased_image);
+
+        const bool both_2d{image.info.type == ImageType::e2D &&
+                           aliased_image.info.type == ImageType::e2D};
+        auto copies = aliased->copies;
+        for (auto copy : copies) {
+            copy.extent.width = std::max<u32>(
+                (copy.extent.width * resolution.up_scale) >> resolution.down_shift, 1);
+            if (both_2d) {
+                copy.extent.height = std::max<u32>(
+                    (copy.extent.height * resolution.up_scale) >> resolution.down_shift, 1);
             }
         }
-        CopyImage(image_id, aliased->id, aliased->copies);
+        CopyImage(image_id, aliased->id, copies);
     }
 }
 
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index 59cf2f561..9922aa0cc 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -723,7 +723,7 @@ ImageViewType RenderTargetImageViewType(const ImageInfo& info) noexcept {
 }
 
 std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageInfo& src,
-                                             SubresourceBase base) {
+                                             SubresourceBase base, u32 up_scale, u32 down_shift) {
     ASSERT(dst.resources.levels >= src.resources.levels);
     ASSERT(dst.num_samples == src.num_samples);
 
@@ -732,7 +732,7 @@ std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageIn
         ASSERT(src.type == ImageType::e3D);
         ASSERT(src.resources.levels == 1);
     }
-
+    const bool both_2d{src.type == ImageType::e2D && dst.type == ImageType::e2D};
     std::vector<ImageCopy> copies;
     copies.reserve(src.resources.levels);
     for (s32 level = 0; level < src.resources.levels; ++level) {
@@ -762,6 +762,10 @@ std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageIn
         if (is_dst_3d) {
             copy.extent.depth = src.size.depth;
         }
+        copy.extent.width = std::max<u32>((copy.extent.width * up_scale) >> down_shift, 1);
+        if (both_2d) {
+            copy.extent.height = std::max<u32>((copy.extent.height * up_scale) >> down_shift, 1);
+        }
     }
     return copies;
 }
diff --git a/src/video_core/texture_cache/util.h b/src/video_core/texture_cache/util.h
index 766502908..7af52de2e 100644
--- a/src/video_core/texture_cache/util.h
+++ b/src/video_core/texture_cache/util.h
@@ -55,7 +55,8 @@ struct OverlapResult {
 
 [[nodiscard]] std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst,
                                                            const ImageInfo& src,
-                                                           SubresourceBase base);
+                                                           SubresourceBase base, u32 up_scale = 1,
+                                                           u32 down_shift = 0);
 
 [[nodiscard]] bool IsValidEntry(const Tegra::MemoryManager& gpu_memory, const TICEntry& config);
 
-- 
cgit v1.2.3


From bf01b7993dca835a516abdc2142be96bc0f216ec Mon Sep 17 00:00:00 2001
From: FernandoS27
Date: Wed, 20 Oct 2021 23:21:52 +0200
Subject: TextureCache: Improve Reaper.

---
 src/video_core/texture_cache/texture_cache.h      | 38 +++++++++++++++--------
 src/video_core/texture_cache/texture_cache_base.h |  2 +-
 2 files changed, 26 insertions(+), 14 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 a32c11d04..f1254ef62 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -51,8 +51,8 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
 
     if constexpr (HAS_DEVICE_MEMORY_INFO) {
         const auto device_memory = runtime.GetDeviceLocalMemory();
-        const u64 possible_expected_memory = (device_memory * 3) / 10;
-        const u64 possible_critical_memory = (device_memory * 6) / 10;
+        const u64 possible_expected_memory = (device_memory * 4) / 10;
+        const u64 possible_critical_memory = (device_memory * 7) / 10;
         expected_memory = std::max(possible_expected_memory, DEFAULT_EXPECTED_MEMORY);
         critical_memory = std::max(possible_critical_memory, DEFAULT_CRITICAL_MEMORY);
         minimum_memory = 0;
@@ -69,7 +69,7 @@ void TextureCache<P>::RunGarbageCollector() {
     const bool high_priority_mode = total_used_memory >= expected_memory;
     const bool aggressive_mode = total_used_memory >= critical_memory;
     const u64 ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 100ULL;
-    size_t num_iterations = aggressive_mode ? 10000 : (high_priority_mode ? 100 : 5);
+    size_t num_iterations = aggressive_mode ? 300 : (high_priority_mode ? 50 : 10);
     const auto clean_up = [this, &num_iterations, high_priority_mode](ImageId image_id) {
         if (num_iterations == 0) {
             return true;
@@ -91,7 +91,7 @@ void TextureCache<P>::RunGarbageCollector() {
             UntrackImage(image, image_id);
         }
         UnregisterImage(image_id);
-        DeleteImage(image_id);
+        DeleteImage(image_id, image.scale_tick > frame_tick + 5);
         return false;
     };
     lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, clean_up);
@@ -287,7 +287,9 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         if (image_id != CORRUPT_ID) {
             Image& image = slot_images[image_id];
             image.scale_rating = scale_rating;
-            image.scale_tick = frame_tick + 1;
+            if (image.scale_tick <= frame_tick) {
+                image.scale_tick = frame_tick + 1;
+            }
         }
     };
     for (size_t index = 0; index < NUM_RT; ++index) {
@@ -810,6 +812,9 @@ bool TextureCache<P>::ImageCanRescale(ImageBase& image) {
 
 template <class P>
 void TextureCache<P>::InvalidateScale(Image& image) {
+    if (image.scale_tick <= frame_tick) {
+        image.scale_tick = frame_tick + 1;
+    }
     const std::span<const ImageViewId> image_view_ids = image.image_view_ids;
     auto& dirty = maxwell3d.dirty.flags;
     dirty[Dirty::RenderTargets] = true;
@@ -842,12 +847,15 @@ void TextureCache<P>::InvalidateScale(Image& image) {
 
 template <class P>
 u64 TextureCache<P>::GetScaledImageSizeBytes(ImageBase& image) {
-    const f32 add_to_size = Settings::values.resolution_info.up_factor;
-    const bool sign = std::signbit(add_to_size);
-    const u32 image_size_bytes = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
-    const u64 tentative_size = image_size_bytes * static_cast<u64>(std::abs(add_to_size));
+    const u64 scale_up = static_cast<u64>(Settings::values.resolution_info.up_scale *
+                                          Settings::values.resolution_info.up_scale);
+    const u64 down_shift = static_cast<u64>(Settings::values.resolution_info.down_shift +
+                                            Settings::values.resolution_info.down_shift);
+    const u64 image_size_bytes =
+        static_cast<u64>(std::max(image.guest_size_bytes, image.unswizzled_size_bytes));
+    const u64 tentative_size = (image_size_bytes * scale_up) >> down_shift;
     const u64 fitted_size = Common::AlignUp(tentative_size, 1024);
-    return sign ? -fitted_size : fitted_size;
+    return fitted_size;
 }
 
 template <class P>
@@ -1510,7 +1518,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
 }
 
 template <class P>
-void TextureCache<P>::DeleteImage(ImageId image_id) {
+void TextureCache<P>::DeleteImage(ImageId image_id, bool immediate_delete) {
     ImageBase& image = slot_images[image_id];
     if (image.HasScaled()) {
         total_used_memory -= GetScaledImageSizeBytes(image);
@@ -1576,10 +1584,14 @@ void TextureCache<P>::DeleteImage(ImageId image_id) {
                    num_removed_overlaps);
     }
     for (const ImageViewId image_view_id : image_view_ids) {
-        sentenced_image_view.Push(std::move(slot_image_views[image_view_id]));
+        if (!immediate_delete) {
+            sentenced_image_view.Push(std::move(slot_image_views[image_view_id]));
+        }
         slot_image_views.erase(image_view_id);
     }
-    sentenced_images.Push(std::move(slot_images[image_id]));
+    if (!immediate_delete) {
+        sentenced_images.Push(std::move(slot_images[image_id]));
+    }
     slot_images.erase(image_id);
 
     alloc_images.erase(alloc_image_it);
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index 4f876b2f4..eea589269 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -292,7 +292,7 @@ private:
     void UntrackImage(ImageBase& image, ImageId image_id);
 
     /// Delete image from the cache
-    void DeleteImage(ImageId image);
+    void DeleteImage(ImageId image, bool immediate_delete = false);
 
     /// Remove image views references from the cache
     void RemoveImageViewReferences(std::span<const ImageViewId> removed_views);
-- 
cgit v1.2.3


From 6cdfaee7b4f3f68310e9cca755482e3e6993da10 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Thu, 21 Oct 2021 21:31:33 +0200
Subject: Texture Cache: Fix blitting.

---
 src/video_core/texture_cache/util.cpp | 4 ++--
 1 file changed, 2 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 9922aa0cc..ddc9fb13a 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1157,10 +1157,10 @@ void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase*
     if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
         dst_info.format = dst->info.format;
     }
-    if (!dst && src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
         dst_info.format = src->info.format;
     }
-    if (!src && dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
+    if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
         src_info.format = dst->info.format;
     }
 }
-- 
cgit v1.2.3


From 5c6fa8893589fd70bc743c0d0b77c0c375b24bd3 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sat, 23 Oct 2021 01:52:34 +0200
Subject: OpenGlTextureCache: Fix state invalidation on rescaling.

---
 src/video_core/texture_cache/texture_cache.h | 4 ++--
 1 file changed, 2 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 f1254ef62..dd9553806 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1810,8 +1810,8 @@ void TextureCache<P>::BindRenderTarget(ImageViewId* old_id, ImageViewId new_id)
     if (*old_id == new_id) {
         return;
     }
-    if (*old_id) {
-        const ImageViewBase& old_view = slot_image_views[*old_id];
+    if (new_id) {
+        const ImageViewBase& old_view = slot_image_views[new_id];
         if (True(old_view.flags & ImageViewFlagBits::PreemtiveDownload)) {
             uncommitted_downloads.push_back(old_view.image_id);
         }
-- 
cgit v1.2.3


From 099b0b3167d6dc47b764331f40aa935e8a9ef86a Mon Sep 17 00:00:00 2001
From: FernandoS27
Date: Sat, 23 Oct 2021 17:17:02 +0200
Subject: Texture Cache: Fix memory usage on ScaleDown.

---
 src/video_core/texture_cache/texture_cache.h | 4 ----
 1 file changed, 4 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 dd9553806..26ab857c9 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -878,10 +878,6 @@ bool TextureCache<P>::ScaleDown(Image& image) {
     if (!rescaled) {
         return false;
     }
-    const bool has_copy = image.HasScaled();
-    if (!has_copy) {
-        total_used_memory -= GetScaledImageSizeBytes(image);
-    }
     InvalidateScale(image);
     return true;
 }
-- 
cgit v1.2.3


From 917b2466ad996cae75d9a0ca31226597b256acf9 Mon Sep 17 00:00:00 2001
From: ameerj
Date: Sun, 24 Oct 2021 23:07:15 -0400
Subject: texture_cache: Refactor Render Target scaling function

---
 src/video_core/texture_cache/texture_cache.h      | 33 +++++++++++++----------
 src/video_core/texture_cache/texture_cache_base.h |  5 ++++
 2 files changed, 24 insertions(+), 14 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 26ab857c9..c8031b695 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -192,19 +192,8 @@ void TextureCache<P>::SynchronizeComputeDescriptors() {
 }
 
 template <class P>
-void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
-    using namespace VideoCommon::Dirty;
+bool TextureCache<P>::RescaleRenderTargets(bool is_clear) {
     auto& flags = maxwell3d.dirty.flags;
-    if (!flags[Dirty::RenderTargets]) {
-        for (size_t index = 0; index < NUM_RT; ++index) {
-            ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
-            PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));
-        }
-        const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
-        PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
-        return;
-    }
-
     u32 scale_rating = 0;
     bool rescaled = false;
     std::array<ImageId, NUM_RT> tmp_color_images{};
@@ -281,8 +270,6 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
             scale_rating = 1;
         }
     } while (has_deleted_images);
-    // Rescale End
-
     const auto set_rating = [this, scale_rating](ImageId image_id) {
         if (image_id != CORRUPT_ID) {
             Image& image = slot_images[image_id];
@@ -297,6 +284,24 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
     }
     set_rating(tmp_depth_image);
 
+    return rescaled;
+}
+
+template <class P>
+void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
+    using namespace VideoCommon::Dirty;
+    auto& flags = maxwell3d.dirty.flags;
+    if (!flags[Dirty::RenderTargets]) {
+        for (size_t index = 0; index < NUM_RT; ++index) {
+            ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
+            PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));
+        }
+        const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
+        PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
+        return;
+    }
+
+    const bool rescaled = RescaleRenderTargets(is_clear);
     if (is_rescaling != rescaled) {
         flags[Dirty::RescaleViewports] = true;
         flags[Dirty::RescaleScissors] = true;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index eea589269..643ad811c 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -119,6 +119,11 @@ public:
     /// Refresh the state for compute image view and sampler descriptors
     void SynchronizeComputeDescriptors();
 
+    /// Updates the Render Targets if they can be rescaled
+    /// @param is_clear True when the render targets are being used for clears
+    /// @retval True if the Render Targets have been rescaled.
+    bool RescaleRenderTargets(bool is_clear);
+
     /// Update bound render targets and upload memory if necessary
     /// @param is_clear True when the render targets are being used for clears
     void UpdateRenderTargets(bool is_clear);
-- 
cgit v1.2.3


From de1c8c5c2c3131bb122351e676014cdc7c442e78 Mon Sep 17 00:00:00 2001
From: FernandoS27
Date: Fri, 29 Oct 2021 17:02:57 +0200
Subject: Texture Cahe/Shader decompiler: Resize PointSize on rescaling,
 refactor and make reaper more agressive on 4Gb GPUs.

---
 src/video_core/texture_cache/image_base.h    |  1 -
 src/video_core/texture_cache/image_info.cpp  |  6 +++---
 src/video_core/texture_cache/texture_cache.h | 18 ++----------------
 3 files changed, 5 insertions(+), 20 deletions(-)

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_base.h b/src/video_core/texture_cache/image_base.h
index 02c669766..89c111c00 100644
--- a/src/video_core/texture_cache/image_base.h
+++ b/src/video_core/texture_cache/image_base.h
@@ -38,7 +38,6 @@ enum class ImageFlagBits : u32 {
     Rescaled = 1 << 12,
     CheckingRescalable = 1 << 13,
     IsRescalable = 1 << 14,
-    Blacklisted = 1 << 15,
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index d8e414247..015a2d33d 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -135,7 +135,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         type = ImageType::e3D;
         size.depth = rt.depth;
     } else {
-        rescaleable = block.depth == 0 && size.height > 256;
+        rescaleable = block.depth == 0;
         downscaleable = size.height > 512;
         type = ImageType::e2D;
         resources.layers = rt.depth;
@@ -165,7 +165,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept {
         type = ImageType::e3D;
         size.depth = regs.zeta_depth;
     } else {
-        rescaleable = block.depth == 0 && size.height > 256;
+        rescaleable = block.depth == 0;
         downscaleable = size.height > 512;
         type = ImageType::e2D;
         resources.layers = regs.zeta_depth;
@@ -199,7 +199,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
             .height = config.height,
             .depth = 1,
         };
-        rescaleable = block.depth == 0 && size.height > 256;
+        rescaleable = block.depth == 0;
         downscaleable = size.height > 512;
     }
 }
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index c8031b695..aec130a32 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -53,8 +53,8 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
         const auto device_memory = runtime.GetDeviceLocalMemory();
         const u64 possible_expected_memory = (device_memory * 4) / 10;
         const u64 possible_critical_memory = (device_memory * 7) / 10;
-        expected_memory = std::max(possible_expected_memory, DEFAULT_EXPECTED_MEMORY);
-        critical_memory = std::max(possible_critical_memory, DEFAULT_CRITICAL_MEMORY);
+        expected_memory = std::max(possible_expected_memory, DEFAULT_EXPECTED_MEMORY - 256_MiB);
+        critical_memory = std::max(possible_critical_memory, DEFAULT_CRITICAL_MEMORY - 512_MiB);
         minimum_memory = 0;
     } else {
         // On OpenGL we can be more conservatives as the driver takes care.
@@ -355,7 +355,6 @@ void TextureCache<P>::FillImageViews(DescriptorTable<TICEntry>& table,
                 if (view.blacklist && view.id != NULL_IMAGE_VIEW_ID) {
                     const ImageViewBase& image_view{slot_image_views[view.id]};
                     auto& image = slot_images[image_view.image_id];
-                    image.flags |= ImageFlagBits::Blacklisted;
                     has_blacklisted |= ScaleDown(image);
                     image.scale_rating = 0;
                 }
@@ -985,7 +984,6 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
 
     bool can_rescale = info.rescaleable;
     bool any_rescaled = false;
-    bool any_blacklisted = false;
     for (const ImageId sibling_id : all_siblings) {
         if (!can_rescale) {
             break;
@@ -993,7 +991,6 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         Image& sibling = slot_images[sibling_id];
         can_rescale &= ImageCanRescale(sibling);
         any_rescaled |= True(sibling.flags & ImageFlagBits::Rescaled);
-        any_blacklisted |= True(sibling.flags & ImageFlagBits::Blacklisted);
     }
 
     can_rescale &= any_rescaled;
@@ -1007,9 +1004,6 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         for (const ImageId sibling_id : all_siblings) {
             Image& sibling = slot_images[sibling_id];
             ScaleDown(sibling);
-            if (any_blacklisted) {
-                sibling.flags |= ImageFlagBits::Blacklisted;
-            }
         }
     }
 
@@ -1644,7 +1638,6 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
     boost::container::small_vector<const AliasedImage*, 1> aliased_images;
     Image& image = slot_images[image_id];
     bool any_rescaled = True(image.flags & ImageFlagBits::Rescaled);
-    bool any_blacklisted = True(image.flags & ImageFlagBits::Blacklisted);
     u64 most_recent_tick = image.modification_tick;
     for (const AliasedImage& aliased : image.aliased_images) {
         ImageBase& aliased_image = slot_images[aliased.id];
@@ -1652,7 +1645,6 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
             most_recent_tick = std::max(most_recent_tick, aliased_image.modification_tick);
             aliased_images.push_back(&aliased);
             any_rescaled |= True(aliased_image.flags & ImageFlagBits::Rescaled);
-            any_blacklisted |= True(aliased_image.flags & ImageFlagBits::Blacklisted);
         }
     }
     if (aliased_images.empty()) {
@@ -1664,9 +1656,6 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
             ScaleUp(image);
         } else {
             ScaleDown(image);
-            if (any_blacklisted) {
-                image.flags |= ImageFlagBits::Blacklisted;
-            }
         }
     }
     image.modification_tick = most_recent_tick;
@@ -1684,9 +1673,6 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
         Image& aliased_image = slot_images[aliased->id];
         if (!can_rescale) {
             ScaleDown(aliased_image);
-            if (any_blacklisted) {
-                aliased_image.flags |= ImageFlagBits::Blacklisted;
-            }
             CopyImage(image_id, aliased->id, aliased->copies);
             continue;
         }
-- 
cgit v1.2.3


From 6c97ab571a3d169d1d2a5472040d4373ea61184d Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Sat, 30 Oct 2021 01:50:32 +0200
Subject: Texture Cache: revert Image changes.

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

(limited to 'src/video_core/texture_cache')

diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cpp
index 015a2d33d..afb94082b 100644
--- a/src/video_core/texture_cache/image_info.cpp
+++ b/src/video_core/texture_cache/image_info.cpp
@@ -16,6 +16,7 @@ namespace VideoCommon {
 using Tegra::Texture::TextureType;
 using Tegra::Texture::TICEntry;
 using VideoCore::Surface::PixelFormat;
+using VideoCore::Surface::SurfaceType;
 
 ImageInfo::ImageInfo(const TICEntry& config) noexcept {
     format = PixelFormatFromTextureInfo(config.format, config.r_type, config.g_type, config.b_type,
@@ -102,6 +103,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         layer_stride = CalculateLayerStride(*this);
         maybe_unaligned_layer_stride = CalculateLayerSize(*this);
         rescaleable &= (block.depth == 0) && resources.levels == 1;
+        rescaleable &= size.height > 256 || GetFormatType(format) != SurfaceType::ColorTexture;
         downscaleable = size.height > 512;
     }
 }
@@ -136,6 +138,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index)
         size.depth = rt.depth;
     } else {
         rescaleable = block.depth == 0;
+        rescaleable &= size.height > 256;
         downscaleable = size.height > 512;
         type = ImageType::e2D;
         resources.layers = rt.depth;
@@ -200,6 +203,7 @@ ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept {
             .depth = 1,
         };
         rescaleable = block.depth == 0;
+        rescaleable &= size.height > 256;
         downscaleable = size.height > 512;
     }
 }
-- 
cgit v1.2.3


From 978f598ff64d3bd0299d06c47e6cbd63a496122c Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow
Date: Wed, 17 Nov 2021 00:59:46 +0100
Subject: TextureCache: Fix OGL cleaning

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

(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 aec130a32..4d2874bf2 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1620,6 +1620,9 @@ void TextureCache<P>::RemoveFramebuffers(std::span<const ImageViewId> removed_vi
     auto it = framebuffers.begin();
     while (it != framebuffers.end()) {
         if (it->first.Contains(removed_views)) {
+            auto framebuffer_id = it->second;
+            ASSERT(framebuffer_id);
+            sentenced_framebuffers.Push(std::move(slot_framebuffers[framebuffer_id]));
             it = framebuffers.erase(it);
         } else {
             ++it;
-- 
cgit v1.2.3