const fixes

general: Resolve comments in PR #7368

.ci/scripts/merge/apply-patches-by-label-private.py

@@ -25,7 +25,7 @@ def check_individual(repo_id, pr_id):
 
 def merge_pr(pn, ref):
     print("Matched PR# %s" % pn)
-    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f"]))
+    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f", "--no-recurse-submodules"]))
     print(subprocess.check_output(["git", "merge", "--squash", 'origin/' + ref.replace('refs/heads/','')]))
     print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
 

.ci/scripts/merge/apply-patches-by-label.py

@@ -25,7 +25,7 @@ def do_page(page):
             if (check_individual(pr["labels"])):
                 pn = pr["number"]
                 print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
+                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f", "--no-recurse-submodules"]))
                 print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
                 print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
 

CMakeLists.txt

@@ -57,7 +57,7 @@ function(check_submodules_present)
         string(REGEX REPLACE "path *= *" "" module ${module})
         if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
             message(FATAL_ERROR "Git submodule ${module} not found. "
-                    "Please run: git submodule update --init --recursive")
+                    "Please run: \ngit submodule update --init --recursive")
         endif()
     endforeach()
 endfunction()

src/common/bit_util.h

@@ -7,6 +7,7 @@
 #include <bit>
 #include <climits>
 #include <cstddef>
+#include <type_traits>
 
 #include "common/common_types.h"
 
@@ -44,4 +45,10 @@ template <typename T>
     return static_cast<u32>(log2_f + static_cast<u64>((value ^ (1ULL << log2_f)) != 0ULL));
 }
 
+template <typename T>
+requires std::is_integral_v<T>
+[[nodiscard]] T NextPow2(T value) {
+    return static_cast<T>(1ULL << ((8U * sizeof(T)) - std::countl_zero(value - 1U)));
+}
+
 } // namespace Common

src/core/frontend/framebuffer_layout.cpp

@@ -25,7 +25,12 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
     // so just calculate them both even if the other isn't showing.
-    FramebufferLayout res{width, height, false, {}};
+    FramebufferLayout res{
+        .width = width,
+        .height = height,
+        .screen = {},
+        .is_srgb = false,
+    };
 
     const float window_aspect_ratio = static_cast<float>(height) / static_cast<float>(width);
     const float emulation_aspect_ratio = EmulationAspectRatio(

src/core/frontend/framebuffer_layout.h

@@ -35,17 +35,8 @@ enum class AspectRatio {
 struct FramebufferLayout {
     u32 width{ScreenUndocked::Width};
     u32 height{ScreenUndocked::Height};
-    bool is_srgb{};
-
     Common::Rectangle<u32> screen;
-
-    /**
-     * Returns the ration of pixel size of the screen, compared to the native size of the undocked
-     * Switch screen.
-     */
-    float GetScalingRatio() const {
-        return static_cast<float>(screen.GetWidth()) / ScreenUndocked::Width;
-    }
+    bool is_srgb{};
 };
 
 /**

src/core/hle/kernel/kernel.cpp

@@ -300,15 +300,16 @@ struct KernelCore::Impl {
     // Gets the dummy KThread for the caller, allocating a new one if this is the first time
     KThread* GetHostDummyThread() {
         auto make_thread = [this]() {
-            std::unique_ptr<KThread> thread = std::make_unique<KThread>(system.Kernel());
+            std::lock_guard lk(dummy_thread_lock);
+            auto& thread = dummy_threads.emplace_back(std::make_unique<KThread>(system.Kernel()));
             KAutoObject::Create(thread.get());
             ASSERT(KThread::InitializeDummyThread(thread.get()).IsSuccess());
             thread->SetName(fmt::format("DummyThread:{}", GetHostThreadId()));
-            return thread;
+            return thread.get();
         };
 
-        thread_local auto thread = make_thread();
-        return thread.get();
+        thread_local KThread* saved_thread = make_thread();
+        return saved_thread;
     }
 
     /// Registers a CPU core thread by allocating a host thread ID for it
@@ -695,6 +696,12 @@ struct KernelCore::Impl {
         return port;
     }
 
+    std::mutex server_ports_lock;
+    std::mutex server_sessions_lock;
+    std::mutex registered_objects_lock;
+    std::mutex registered_in_use_objects_lock;
+    std::mutex dummy_thread_lock;
+
     std::atomic<u32> next_object_id{0};
     std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin};
     std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin};
@@ -725,10 +732,6 @@ struct KernelCore::Impl {
     std::unordered_set<KServerSession*> server_sessions;
     std::unordered_set<KAutoObject*> registered_objects;
     std::unordered_set<KAutoObject*> registered_in_use_objects;
-    std::mutex server_ports_lock;
-    std::mutex server_sessions_lock;
-    std::mutex registered_objects_lock;
-    std::mutex registered_in_use_objects_lock;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::vector<Kernel::PhysicalCore> cores;
@@ -753,6 +756,9 @@ struct KernelCore::Impl {
     std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
+    // Specifically tracked to be automatically destroyed with kernel
+    std::vector<std::unique_ptr<KThread>> dummy_threads;
+
     bool is_multicore{};
     bool is_phantom_mode_for_singlecore{};
     u32 single_core_thread_id{};

src/core/hle/service/pm/pm.cpp

@@ -13,7 +13,12 @@ namespace Service::PM {
 
 namespace {
 
-constexpr ResultCode ERROR_PROCESS_NOT_FOUND{ErrorModule::PM, 1};
+constexpr ResultCode ResultProcessNotFound{ErrorModule::PM, 1};
+[[maybe_unused]] constexpr ResultCode ResultAlreadyStarted{ErrorModule::PM, 2};
+[[maybe_unused]] constexpr ResultCode ResultNotTerminated{ErrorModule::PM, 3};
+[[maybe_unused]] constexpr ResultCode ResultDebugHookInUse{ErrorModule::PM, 4};
+[[maybe_unused]] constexpr ResultCode ResultApplicationRunning{ErrorModule::PM, 5};
+[[maybe_unused]] constexpr ResultCode ResultInvalidSize{ErrorModule::PM, 6};
 
 constexpr u64 NO_PROCESS_FOUND_PID{0};
 
@@ -95,18 +100,18 @@ public:
 private:
     void GetProcessId(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto title_id = rp.PopRaw<u64>();
+        const auto program_id = rp.PopRaw<u64>();
 
-        LOG_DEBUG(Service_PM, "called, title_id={:016X}", title_id);
+        LOG_DEBUG(Service_PM, "called, program_id={:016X}", program_id);
 
         const auto process =
-            SearchProcessList(kernel.GetProcessList(), [title_id](const auto& proc) {
-                return proc->GetProgramID() == title_id;
+            SearchProcessList(kernel.GetProcessList(), [program_id](const auto& proc) {
+                return proc->GetProgramID() == program_id;
             });
 
         if (!process.has_value()) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_PROCESS_NOT_FOUND);
+            rb.Push(ResultProcessNotFound);
             return;
         }
 
@@ -128,13 +133,16 @@ public:
     explicit Info(Core::System& system_, const std::vector<Kernel::KProcess*>& process_list_)
         : ServiceFramework{system_, "pm:info"}, process_list{process_list_} {
         static const FunctionInfo functions[] = {
-            {0, &Info::GetTitleId, "GetTitleId"},
+            {0, &Info::GetProgramId, "GetProgramId"},
+            {65000, &Info::AtmosphereGetProcessId, "AtmosphereGetProcessId"},
+            {65001, nullptr, "AtmosphereHasLaunchedProgram"},
+            {65002, nullptr, "AtmosphereGetProcessInfo"},
         };
         RegisterHandlers(functions);
     }
 
 private:
-    void GetTitleId(Kernel::HLERequestContext& ctx) {
+    void GetProgramId(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto process_id = rp.PopRaw<u64>();
 
@@ -146,7 +154,7 @@ private:
 
         if (!process.has_value()) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_PROCESS_NOT_FOUND);
+            rb.Push(ResultProcessNotFound);
             return;
         }
 
@@ -155,6 +163,27 @@ private:
         rb.Push((*process)->GetProgramID());
     }
 
+    void AtmosphereGetProcessId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto program_id = rp.PopRaw<u64>();
+
+        LOG_DEBUG(Service_PM, "called, program_id={:016X}", program_id);
+
+        const auto process = SearchProcessList(process_list, [program_id](const auto& proc) {
+            return proc->GetProgramID() == program_id;
+        });
+
+        if (!process.has_value()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ResultProcessNotFound);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push((*process)->GetProcessID());
+    }
+
     const std::vector<Kernel::KProcess*>& process_list;
 };
 

src/video_core/host_shaders/CMakeLists.txt

@@ -10,8 +10,14 @@ set(SHADER_FILES
     astc_decoder.comp
     block_linear_unswizzle_2d.comp
     block_linear_unswizzle_3d.comp
+    convert_abgr8_to_d24s8.frag
+    convert_b10g11r11_to_d24s8.frag
+    convert_d24s8_to_abgr8.frag
+    convert_d24s8_to_b10g11r11.frag
+    convert_d24s8_to_r16g16.frag
     convert_depth_to_float.frag
     convert_float_to_depth.frag
+    convert_r16g16_to_d24s8.frag
     full_screen_triangle.vert
     fxaa.frag
     fxaa.vert

src/video_core/host_shaders/convert_abgr8_to_d24s8.frag

@@ -0,0 +1,17 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+#extension GL_ARB_shader_stencil_export : require
+
+layout(binding = 0) uniform sampler2D color_texture;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uvec4 color = uvec4(texelFetch(color_texture, coord, 0).rgba * (exp2(8) - 1.0f));
+    uint depth_unorm = (color.r << 16) | (color.g << 8) | color.b;
+
+    gl_FragDepth = float(depth_unorm) / (exp2(24.0) - 1.0f);
+    gl_FragStencilRefARB = int(color.a);
+}

src/video_core/host_shaders/convert_b10g11r11_to_d24s8.frag

@@ -0,0 +1,19 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+#extension GL_ARB_shader_stencil_export : require
+
+layout(binding = 0) uniform sampler2D color_texture;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    vec4 color = texelFetch(color_texture, coord, 0).rgba;
+    uint depth_stencil_unorm = (uint(color.b * (exp2(10) - 1.0f)) << 22)
+                      | (uint(color.g * (exp2(11) - 1.0f)) << 11)
+                      | (uint(color.r * (exp2(11) - 1.0f)));
+
+    gl_FragDepth = float(depth_stencil_unorm >> 8) / (exp2(24.0) - 1.0f);
+    gl_FragStencilRefARB = int(depth_stencil_unorm & 0x00FF);
+}

src/video_core/host_shaders/convert_d24s8_to_abgr8.frag

@@ -0,0 +1,21 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+
+layout(binding = 0) uniform sampler2D depth_tex;
+layout(binding = 1) uniform isampler2D stencil_tex;
+
+layout(location = 0) out vec4 color;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
+    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
+
+    color.r = float(depth >> 16) / (exp2(8) - 1.0);
+    color.g = float((depth >> 8) & 0x00FF) / (exp2(8) - 1.0);
+    color.b = float(depth & 0x00FF) / (exp2(8) - 1.0);
+    color.a = float(stencil) / (exp2(8) - 1.0);
+}

src/video_core/host_shaders/convert_d24s8_to_b10g11r11.frag

@@ -0,0 +1,21 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+
+layout(binding = 0) uniform sampler2D depth_tex;
+layout(binding = 1) uniform isampler2D stencil_tex;
+
+layout(location = 0) out vec4 color;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
+    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
+
+    color.b = float(depth >> 22) / (exp2(10) - 1.0);
+    color.g = float((depth >> 11) & 0x00FF) / (exp2(11) - 1.0);
+    color.r = float(depth & 0x00FF) / (exp2(11) - 1.0);
+    color.a = 1.0f;
+}

src/video_core/host_shaders/convert_d24s8_to_r16g16.frag

@@ -0,0 +1,21 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+
+layout(binding = 0) uniform sampler2D depth_tex;
+layout(binding = 1) uniform isampler2D stencil_tex;
+
+layout(location = 0) out vec4 color;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
+    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
+
+    color.r = float(depth >> 16) / (exp2(16) - 1.0);
+    color.g = float((depth >> 16) & 0x00FF) / (exp2(16) - 1.0);
+    color.b = 0.0f;
+    color.a = 1.0f;
+}

src/video_core/host_shaders/convert_r16g16_to_d24s8.frag

@@ -0,0 +1,18 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 450
+#extension GL_ARB_shader_stencil_export : require
+
+layout(binding = 0) uniform sampler2D color_texture;
+
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    vec4 color = texelFetch(color_texture, coord, 0).rgba;
+    uint depth_stencil_unorm = (uint(color.r * (exp2(16) - 1.0f)) << 16)
+                      | (uint(color.g * (exp2(16) - 1.0f)) << 16);
+
+    gl_FragDepth = float(depth_stencil_unorm >> 8) / (exp2(24.0) - 1.0f);
+    gl_FragStencilRefARB = int(depth_stencil_unorm & 0x00FF);
+}

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -9,6 +9,7 @@
 
 #include <glad/glad.h>
 
+#include "common/bit_util.h"
 #include "common/literals.h"
 #include "common/settings.h"
 #include "video_core/renderer_opengl/gl_device.h"
@@ -319,13 +320,12 @@ void AttachTexture(GLuint fbo, GLenum attachment, const ImageView* image_view) {
     }
 }
 
-OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_format) {
+OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_format,
+                     GLsizei gl_num_levels) {
     const GLenum target = ImageTarget(info);
     const GLsizei width = info.size.width;
     const GLsizei height = info.size.height;
     const GLsizei depth = info.size.depth;
-    const int max_host_mip_levels = std::bit_width(info.size.width);
-    const GLsizei num_levels = std::min(info.resources.levels, max_host_mip_levels);
     const GLsizei num_layers = info.resources.layers;
     const GLsizei num_samples = info.num_samples;
 
@@ -337,10 +337,10 @@ OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_form
     }
     switch (target) {
     case GL_TEXTURE_1D_ARRAY:
-        glTextureStorage2D(handle, num_levels, gl_internal_format, width, num_layers);
+        glTextureStorage2D(handle, gl_num_levels, gl_internal_format, width, num_layers);
         break;
     case GL_TEXTURE_2D_ARRAY:
-        glTextureStorage3D(handle, num_levels, gl_internal_format, width, height, num_layers);
+        glTextureStorage3D(handle, gl_num_levels, gl_internal_format, width, height, num_layers);
         break;
     case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: {
         // TODO: Where should 'fixedsamplelocations' come from?
@@ -350,10 +350,10 @@ OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_form
         break;
     }
     case GL_TEXTURE_RECTANGLE:
-        glTextureStorage2D(handle, num_levels, gl_internal_format, width, height);
+        glTextureStorage2D(handle, gl_num_levels, gl_internal_format, width, height);
         break;
     case GL_TEXTURE_3D:
-        glTextureStorage3D(handle, num_levels, gl_internal_format, width, height, depth);
+        glTextureStorage3D(handle, gl_num_levels, gl_internal_format, width, height, depth);
         break;
     case GL_TEXTURE_BUFFER:
         UNREACHABLE();
@@ -398,6 +398,7 @@ OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_form
     UNREACHABLE_MSG("Invalid image format={}", format);
     return GL_R32UI;
 }
+
 } // Anonymous namespace
 
 ImageBufferMap::~ImageBufferMap() {
@@ -524,6 +525,12 @@ void TextureCacheRuntime::CopyImage(Image& dst_image, Image& src_image,
     }
 }
 
+void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
+                                           std::span<const VideoCommon::ImageCopy> copies) {
+    LOG_DEBUG(Render_OpenGL, "Converting {} to {}", src.info.format, dst.info.format);
+    format_conversion_pass.ConvertImage(dst, src, copies);
+}
+
 bool TextureCacheRuntime::CanImageBeCopied(const Image& dst, const Image& src) {
     if (dst.info.type == ImageType::e3D && dst.info.format == PixelFormat::BC4_UNORM) {
         return false;
@@ -540,7 +547,7 @@ void TextureCacheRuntime::EmulateCopyImage(Image& dst, Image& src,
         ASSERT(src.info.type == ImageType::e3D);
         util_shaders.CopyBC4(dst, src, copies);
     } else if (IsPixelFormatBGR(dst.info.format) || IsPixelFormatBGR(src.info.format)) {
-        bgr_copy_pass.CopyBGR(dst, src, copies);
+        format_conversion_pass.ConvertImage(dst, src, copies);
     } else {
         UNREACHABLE();
     }
@@ -688,7 +695,9 @@ Image::Image(TextureCacheRuntime& runtime_, const VideoCommon::ImageInfo& info_,
         gl_format = tuple.format;
         gl_type = tuple.type;
     }
-    texture = MakeImage(info, gl_internal_format);
+    const int max_host_mip_levels = std::bit_width(info.size.width);
+    gl_num_levels = std::min(info.resources.levels, max_host_mip_levels);
+    texture = MakeImage(info, gl_internal_format, gl_num_levels);
     current_texture = texture.handle;
     if (runtime->device.HasDebuggingToolAttached()) {
         const std::string name = VideoCommon::Name(*this);
@@ -716,6 +725,9 @@ void Image::UploadMemory(const ImageBufferMap& map,
     u32 current_image_height = std::numeric_limits<u32>::max();
 
     for (const VideoCommon::BufferImageCopy& copy : copies) {
+        if (copy.image_subresource.base_level >= gl_num_levels) {
+            continue;
+        }
         if (current_row_length != copy.buffer_row_length) {
             current_row_length = copy.buffer_row_length;
             glPixelStorei(GL_UNPACK_ROW_LENGTH, current_row_length);
@@ -745,6 +757,9 @@ void Image::DownloadMemory(ImageBufferMap& map,
     u32 current_image_height = std::numeric_limits<u32>::max();
 
     for (const VideoCommon::BufferImageCopy& copy : copies) {
+        if (copy.image_subresource.base_level >= gl_num_levels) {
+            continue;
+        }
         if (current_row_length != copy.buffer_row_length) {
             current_row_length = copy.buffer_row_length;
             glPixelStorei(GL_PACK_ROW_LENGTH, current_row_length);
@@ -784,7 +799,7 @@ GLuint Image::StorageHandle() noexcept {
         }
         store_view.Create();
         glTextureView(store_view.handle, ImageTarget(info), current_texture, GL_RGBA8, 0,
-                      info.resources.levels, 0, info.resources.layers);
+                      gl_num_levels, 0, info.resources.layers);
         return store_view.handle;
     default:
         return current_texture;
@@ -954,7 +969,7 @@ void Image::Scale(bool up_scale) {
         auto dst_info = info;
         dst_info.size.width = scaled_width;
         dst_info.size.height = scaled_height;
-        upscaled_backup = MakeImage(dst_info, gl_internal_format);
+        upscaled_backup = MakeImage(dst_info, gl_internal_format, gl_num_levels);
     }
     const u32 src_width = up_scale ? original_width : scaled_width;
     const u32 src_height = up_scale ? original_height : scaled_height;
@@ -1304,35 +1319,37 @@ Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM
 
 Framebuffer::~Framebuffer() = default;
 
-void BGRCopyPass::CopyBGR(Image& dst_image, Image& src_image,
-                          std::span<const VideoCommon::ImageCopy> copies) {
-    static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0};
+void FormatConversionPass::ConvertImage(Image& dst_image, Image& src_image,
+                                        std::span<const VideoCommon::ImageCopy> copies) {
+    const GLenum dst_target = ImageTarget(dst_image.info);
+    const GLenum src_target = ImageTarget(src_image.info);
     const u32 img_bpp = BytesPerBlock(src_image.info.format);
     for (const ImageCopy& copy : copies) {
-        ASSERT(copy.src_offset == zero_offset);
-        ASSERT(copy.dst_offset == zero_offset);
-        const u32 num_src_layers = static_cast<u32>(copy.src_subresource.num_layers);
-        const u32 copy_size = copy.extent.width * copy.extent.height * num_src_layers * img_bpp;
-        if (bgr_pbo_size < copy_size) {
-            bgr_pbo.Create();
-            bgr_pbo_size = copy_size;
-            glNamedBufferData(bgr_pbo.handle, bgr_pbo_size, nullptr, GL_STREAM_COPY);
+        const auto src_origin = MakeCopyOrigin(copy.src_offset, copy.src_subresource, src_target);
+        const auto dst_origin = MakeCopyOrigin(copy.dst_offset, copy.dst_subresource, dst_target);
+        const auto region = MakeCopyRegion(copy.extent, copy.dst_subresource, dst_target);
+        const u32 copy_size = region.width * region.height * region.depth * img_bpp;
+        if (pbo_size < copy_size) {
+            intermediate_pbo.Create();
+            pbo_size = Common::NextPow2(copy_size);
+            glNamedBufferData(intermediate_pbo.handle, pbo_size, nullptr, GL_STREAM_COPY);
         }
         // Copy from source to PBO
         glPixelStorei(GL_PACK_ALIGNMENT, 1);
         glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width);
-        glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr_pbo.handle);
-        glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                             num_src_layers, src_image.GlFormat(), src_image.GlType(),
-                             static_cast<GLsizei>(bgr_pbo_size), nullptr);
+        glBindBuffer(GL_PIXEL_PACK_BUFFER, intermediate_pbo.handle);
+        glGetTextureSubImage(src_image.Handle(), src_origin.level, src_origin.x, src_origin.y,
+                             src_origin.z, region.width, region.height, region.depth,
+                             src_image.GlFormat(), src_image.GlType(),
+                             static_cast<GLsizei>(pbo_size), nullptr);
 
         // Copy from PBO to destination in desired GL format
         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
         glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width);
-        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr_pbo.handle);
-        glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                            copy.dst_subresource.num_layers, dst_image.GlFormat(),
-                            dst_image.GlType(), nullptr);
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, intermediate_pbo.handle);
+        glTextureSubImage3D(dst_image.Handle(), dst_origin.level, dst_origin.x, dst_origin.y,
+                            dst_origin.z, region.width, region.height, region.depth,
+                            dst_image.GlFormat(), dst_image.GlType(), nullptr);
     }
 }
 

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -52,17 +52,17 @@ struct FormatProperties {
     bool is_compressed;
 };
 
-class BGRCopyPass {
+class FormatConversionPass {
 public:
-    BGRCopyPass() = default;
-    ~BGRCopyPass() = default;
+    FormatConversionPass() = default;
+    ~FormatConversionPass() = default;
 
-    void CopyBGR(Image& dst_image, Image& src_image,
-                 std::span<const VideoCommon::ImageCopy> copies);
+    void ConvertImage(Image& dst_image, Image& src_image,
+                      std::span<const VideoCommon::ImageCopy> copies);
 
 private:
-    OGLBuffer bgr_pbo;
-    size_t bgr_pbo_size{};
+    OGLBuffer intermediate_pbo;
+    size_t pbo_size{};
 };
 
 class TextureCacheRuntime {
@@ -84,8 +84,14 @@ public:
 
     u64 GetDeviceLocalMemory() const;
 
+    bool ShouldReinterpret([[maybe_unused]] Image& dst, [[maybe_unused]] Image& src) {
+        return true;
+    }
+
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
+    void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+
     void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view, bool rescaled) {
         UNIMPLEMENTED();
     }
@@ -144,7 +150,7 @@ private:
     const Device& device;
     StateTracker& state_tracker;
     UtilShaders util_shaders;
-    BGRCopyPass bgr_copy_pass;
+    FormatConversionPass format_conversion_pass;
 
     std::array<std::unordered_map<GLenum, FormatProperties>, 3> format_properties;
     bool has_broken_texture_view_formats = false;
@@ -219,6 +225,7 @@ private:
     GLenum gl_internal_format = GL_NONE;
     GLenum gl_format = GL_NONE;
     GLenum gl_type = GL_NONE;
+    GLsizei gl_num_levels{};
     TextureCacheRuntime* runtime{};
     GLuint current_texture{};
 };

src/video_core/renderer_vulkan/blit_image.cpp

@@ -4,8 +4,14 @@
 
 #include <algorithm>
 
+#include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
+#include "video_core/host_shaders/convert_b10g11r11_to_d24s8_frag_spv.h"
+#include "video_core/host_shaders/convert_d24s8_to_abgr8_frag_spv.h"
+#include "video_core/host_shaders/convert_d24s8_to_b10g11r11_frag_spv.h"
+#include "video_core/host_shaders/convert_d24s8_to_r16g16_frag_spv.h"
 #include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"
 #include "video_core/host_shaders/convert_float_to_depth_frag_spv.h"
+#include "video_core/host_shaders/convert_r16g16_to_d24s8_frag_spv.h"
 #include "video_core/host_shaders/full_screen_triangle_vert_spv.h"
 #include "video_core/host_shaders/vulkan_blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
@@ -354,6 +360,12 @@ BlitImageHelper::BlitImageHelper(const Device& device_, VKScheduler& scheduler_,
       blit_color_to_color_frag(BuildShader(device, VULKAN_BLIT_COLOR_FLOAT_FRAG_SPV)),
       convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
       convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
+      convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
+      convert_b10g11r11_to_d24s8_frag(BuildShader(device, CONVERT_B10G11R11_TO_D24S8_FRAG_SPV)),
+      convert_r16g16_to_d24s8_frag(BuildShader(device, CONVERT_R16G16_TO_D24S8_FRAG_SPV)),
+      convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
+      convert_d24s8_to_b10g11r11_frag(BuildShader(device, CONVERT_D24S8_TO_B10G11R11_FRAG_SPV)),
+      convert_d24s8_to_r16g16_frag(BuildShader(device, CONVERT_D24S8_TO_R16G16_FRAG_SPV)),
       linear_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_LINEAR>)),
       nearest_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_NEAREST>)) {
     if (device.IsExtShaderStencilExportSupported()) {
@@ -448,6 +460,59 @@ void BlitImageHelper::ConvertR16ToD16(const Framebuffer* dst_framebuffer,
     Convert(*convert_r16_to_d16_pipeline, dst_framebuffer, src_image_view, up_scale, down_shift);
 }
 
+void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
+                                          const ImageView& src_image_view, u32 up_scale,
+                                          u32 down_shift) {
+    ConvertPipelineDepthTargetEx(convert_abgr8_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_abgr8_to_d24s8_frag, true);
+    Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
+            down_shift);
+}
+
+void BlitImageHelper::ConvertB10G11R11ToD24S8(const Framebuffer* dst_framebuffer,
+                                              const ImageView& src_image_view, u32 up_scale,
+                                              u32 down_shift) {
+    ConvertPipelineDepthTargetEx(convert_b10g11r11_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_b10g11r11_to_d24s8_frag, true);
+    Convert(*convert_b10g11r11_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
+            down_shift);
+}
+
+void BlitImageHelper::ConvertR16G16ToD24S8(const Framebuffer* dst_framebuffer,
+                                           const ImageView& src_image_view, u32 up_scale,
+                                           u32 down_shift) {
+    ConvertPipelineDepthTargetEx(convert_r16g16_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_r16g16_to_d24s8_frag, true);
+    Convert(*convert_r16g16_to_d24s8_pipeline, dst_framebuffer, src_image_view, up_scale,
+            down_shift);
+}
+
+void BlitImageHelper::ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer,
+                                          ImageView& src_image_view, u32 up_scale, u32 down_shift) {
+    ConvertPipelineColorTargetEx(convert_d24s8_to_abgr8_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_d24s8_to_abgr8_frag, false);
+    ConvertDepthStencil(*convert_d24s8_to_abgr8_pipeline, dst_framebuffer, src_image_view, up_scale,
+                        down_shift);
+}
+
+void BlitImageHelper::ConvertD24S8ToB10G11R11(const Framebuffer* dst_framebuffer,
+                                              ImageView& src_image_view, u32 up_scale,
+                                              u32 down_shift) {
+    ConvertPipelineColorTargetEx(convert_d24s8_to_b10g11r11_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_d24s8_to_b10g11r11_frag, false);
+    ConvertDepthStencil(*convert_d24s8_to_b10g11r11_pipeline, dst_framebuffer, src_image_view,
+                        up_scale, down_shift);
+}
+
+void BlitImageHelper::ConvertD24S8ToR16G16(const Framebuffer* dst_framebuffer,
+                                           ImageView& src_image_view, u32 up_scale,
+                                           u32 down_shift) {
+    ConvertPipelineColorTargetEx(convert_d24s8_to_r16g16_pipeline, dst_framebuffer->RenderPass(),
+                                 convert_d24s8_to_r16g16_frag, false);
+    ConvertDepthStencil(*convert_d24s8_to_r16g16_pipeline, dst_framebuffer, src_image_view,
+                        up_scale, down_shift);
+}
+
 void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                               const ImageView& src_image_view, u32 up_scale, u32 down_shift) {
     const VkPipelineLayout layout = *one_texture_pipeline_layout;
@@ -495,6 +560,54 @@ void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_frameb
     scheduler.InvalidateState();
 }
 
+void BlitImageHelper::ConvertDepthStencil(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
+                                          ImageView& src_image_view, u32 up_scale, u32 down_shift) {
+    const VkPipelineLayout layout = *two_textures_pipeline_layout;
+    const VkImageView src_depth_view = src_image_view.DepthView();
+    const VkImageView src_stencil_view = src_image_view.StencilView();
+    const VkSampler sampler = *nearest_sampler;
+    const VkExtent2D extent{
+        .width = std::max((src_image_view.size.width * up_scale) >> down_shift, 1U),
+        .height = std::max((src_image_view.size.height * up_scale) >> down_shift, 1U),
+    };
+    scheduler.RequestRenderpass(dst_framebuffer);
+    scheduler.Record([pipeline, layout, sampler, src_depth_view, src_stencil_view, extent, up_scale,
+                      down_shift, this](vk::CommandBuffer cmdbuf) {
+        const VkOffset2D offset{
+            .x = 0,
+            .y = 0,
+        };
+        const VkViewport viewport{
+            .x = 0.0f,
+            .y = 0.0f,
+            .width = static_cast<float>(extent.width),
+            .height = static_cast<float>(extent.height),
+            .minDepth = 0.0f,
+            .maxDepth = 0.0f,
+        };
+        const VkRect2D scissor{
+            .offset = offset,
+            .extent = extent,
+        };
+        const PushConstants push_constants{
+            .tex_scale = {viewport.width, viewport.height},
+            .tex_offset = {0.0f, 0.0f},
+        };
+        const VkDescriptorSet descriptor_set = two_textures_descriptor_allocator.Commit();
+        UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_depth_view,
+                                       src_stencil_view);
+        // TODO: Barriers
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                  nullptr);
+        cmdbuf.SetViewport(0, viewport);
+        cmdbuf.SetScissor(0, scissor);
+        cmdbuf.PushConstants(layout, VK_SHADER_STAGE_VERTEX_BIT, push_constants);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    scheduler.InvalidateState();
+}
+
 VkPipeline BlitImageHelper::FindOrEmplaceColorPipeline(const BlitImagePipelineKey& key) {
     const auto it = std::ranges::find(blit_color_keys, key);
     if (it != blit_color_keys.end()) {
@@ -636,4 +749,44 @@ void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRend
     });
 }
 
+void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                                        vk::ShaderModule& module, bool is_target_depth,
+                                        bool single_texture) {
+    if (pipeline) {
+        return;
+    }
+    const std::array stages = MakeStages(*full_screen_vert, *module);
+    pipeline = device.GetLogical().CreateGraphicsPipeline({
+        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .stageCount = static_cast<u32>(stages.size()),
+        .pStages = stages.data(),
+        .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+        .pInputAssemblyState = &PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+        .pTessellationState = nullptr,
+        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+        .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+        .pDepthStencilState = is_target_depth ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO : nullptr,
+        .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,
+        .pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+        .layout = single_texture ? *one_texture_pipeline_layout : *two_textures_pipeline_layout,
+        .renderPass = renderpass,
+        .subpass = 0,
+        .basePipelineHandle = VK_NULL_HANDLE,
+        .basePipelineIndex = 0,
+    });
+}
+
+void BlitImageHelper::ConvertPipelineColorTargetEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                                                   vk::ShaderModule& module, bool single_texture) {
+    ConvertPipelineEx(pipeline, renderpass, module, false, single_texture);
+}
+
+void BlitImageHelper::ConvertPipelineDepthTargetEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                                                   vk::ShaderModule& module, bool single_texture) {
+    ConvertPipelineEx(pipeline, renderpass, module, true, single_texture);
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/blit_image.h

@@ -56,10 +56,31 @@ public:
     void ConvertR16ToD16(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
                          u32 up_scale, u32 down_shift);
 
+    void ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
+                             u32 up_scale, u32 down_shift);
+
+    void ConvertB10G11R11ToD24S8(const Framebuffer* dst_framebuffer,
+                                 const ImageView& src_image_view, u32 up_scale, u32 down_shift);
+
+    void ConvertR16G16ToD24S8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
+                              u32 up_scale, u32 down_shift);
+
+    void ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
+                             u32 up_scale, u32 down_shift);
+
+    void ConvertD24S8ToB10G11R11(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
+                                 u32 up_scale, u32 down_shift);
+
+    void ConvertD24S8ToR16G16(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
+                              u32 up_scale, u32 down_shift);
+
 private:
     void Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                  const ImageView& src_image_view, u32 up_scale, u32 down_shift);
 
+    void ConvertDepthStencil(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
+                             ImageView& src_image_view, u32 up_scale, u32 down_shift);
+
     [[nodiscard]] VkPipeline FindOrEmplaceColorPipeline(const BlitImagePipelineKey& key);
 
     [[nodiscard]] VkPipeline FindOrEmplaceDepthStencilPipeline(const BlitImagePipelineKey& key);
@@ -68,6 +89,15 @@ private:
 
     void ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass);
 
+    void ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                           vk::ShaderModule& module, bool is_target_depth, bool single_texture);
+
+    void ConvertPipelineColorTargetEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                                      vk::ShaderModule& module, bool single_texture);
+
+    void ConvertPipelineDepthTargetEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
+                                      vk::ShaderModule& module, bool single_texture);
+
     const Device& device;
     VKScheduler& scheduler;
     StateTracker& state_tracker;
@@ -83,6 +113,12 @@ private:
     vk::ShaderModule blit_depth_stencil_frag;
     vk::ShaderModule convert_depth_to_float_frag;
     vk::ShaderModule convert_float_to_depth_frag;
+    vk::ShaderModule convert_abgr8_to_d24s8_frag;
+    vk::ShaderModule convert_b10g11r11_to_d24s8_frag;
+    vk::ShaderModule convert_r16g16_to_d24s8_frag;
+    vk::ShaderModule convert_d24s8_to_abgr8_frag;
+    vk::ShaderModule convert_d24s8_to_b10g11r11_frag;
+    vk::ShaderModule convert_d24s8_to_r16g16_frag;
     vk::Sampler linear_sampler;
     vk::Sampler nearest_sampler;
 
@@ -94,6 +130,12 @@ private:
     vk::Pipeline convert_r32_to_d32_pipeline;
     vk::Pipeline convert_d16_to_r16_pipeline;
     vk::Pipeline convert_r16_to_d16_pipeline;
+    vk::Pipeline convert_abgr8_to_d24s8_pipeline;
+    vk::Pipeline convert_b10g11r11_to_d24s8_pipeline;
+    vk::Pipeline convert_r16g16_to_d24s8_pipeline;
+    vk::Pipeline convert_d24s8_to_abgr8_pipeline;
+    vk::Pipeline convert_d24s8_to_b10g11r11_pipeline;
+    vk::Pipeline convert_d24s8_to_r16g16_pipeline;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "common/bit_cast.h"
+#include "common/bit_util.h"
 #include "common/settings.h"
 
 #include "video_core/engines/fermi_2d.h"
@@ -313,6 +314,19 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
     };
 }
 
+[[nodiscard]] VkBufferImageCopy MakeBufferImageCopy(const VideoCommon::ImageCopy& copy, bool is_src,
+                                                    VkImageAspectFlags aspect_mask) noexcept {
+    return VkBufferImageCopy{
+        .bufferOffset = 0,
+        .bufferRowLength = 0,
+        .bufferImageHeight = 0,
+        .imageSubresource = MakeImageSubresourceLayers(
+            is_src ? copy.src_subresource : copy.dst_subresource, aspect_mask),
+        .imageOffset = MakeOffset3D(is_src ? copy.src_offset : copy.dst_offset),
+        .imageExtent = MakeExtent3D(copy.extent),
+    };
+}
+
 [[maybe_unused]] [[nodiscard]] std::vector<VkBufferCopy> TransformBufferCopies(
     std::span<const VideoCommon::BufferCopy> copies, size_t buffer_offset) {
     std::vector<VkBufferCopy> result(copies.size());
@@ -759,6 +773,163 @@ StagingBufferRef TextureCacheRuntime::DownloadStagingBuffer(size_t size) {
     return staging_buffer_pool.Request(size, MemoryUsage::Download);
 }
 
+bool TextureCacheRuntime::ShouldReinterpret(Image& dst, Image& src) {
+    if (VideoCore::Surface::GetFormatType(dst.info.format) ==
+        VideoCore::Surface::SurfaceType::DepthStencil) {
+        return !device.IsExtShaderStencilExportSupported();
+    }
+    return false;
+}
+
+VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) {
+    const auto level = (8 * sizeof(size_t)) - std::countl_zero(needed_size - 1ULL);
+    if (buffer_commits[level]) {
+        return *buffers[level];
+    }
+    const auto new_size = Common::NextPow2(needed_size);
+    static constexpr VkBufferUsageFlags flags =
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+        VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+    buffers[level] = device.GetLogical().CreateBuffer({
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .size = new_size,
+        .usage = flags,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = nullptr,
+    });
+    buffer_commits[level] = std::make_unique<MemoryCommit>(
+        memory_allocator.Commit(buffers[level], MemoryUsage::DeviceLocal));
+    return *buffers[level];
+}
+
+void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
+                                           std::span<const VideoCommon::ImageCopy> copies) {
+    std::vector<VkBufferImageCopy> vk_in_copies(copies.size());
+    std::vector<VkBufferImageCopy> vk_out_copies(copies.size());
+    const VkImageAspectFlags src_aspect_mask = src.AspectMask();
+    const VkImageAspectFlags dst_aspect_mask = dst.AspectMask();
+
+    std::ranges::transform(copies, vk_in_copies.begin(), [src_aspect_mask](const auto& copy) {
+        return MakeBufferImageCopy(copy, true, src_aspect_mask);
+    });
+    std::ranges::transform(copies, vk_out_copies.begin(), [dst_aspect_mask](const auto& copy) {
+        return MakeBufferImageCopy(copy, false, dst_aspect_mask);
+    });
+    const u32 img_bpp = BytesPerBlock(src.info.format);
+    size_t total_size = 0;
+    for (const auto& copy : copies) {
+        total_size += copy.extent.width * copy.extent.height * copy.extent.depth * img_bpp;
+    }
+    const VkBuffer copy_buffer = GetTemporaryBuffer(total_size);
+    const VkImage dst_image = dst.Handle();
+    const VkImage src_image = src.Handle();
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([dst_image, src_image, copy_buffer, src_aspect_mask, dst_aspect_mask,
+                      vk_in_copies, vk_out_copies](vk::CommandBuffer cmdbuf) {
+        RangedBarrierRange dst_range;
+        RangedBarrierRange src_range;
+        for (const VkBufferImageCopy& copy : vk_in_copies) {
+            src_range.AddLayers(copy.imageSubresource);
+        }
+        for (const VkBufferImageCopy& copy : vk_out_copies) {
+            dst_range.AddLayers(copy.imageSubresource);
+        }
+        static constexpr VkMemoryBarrier READ_BARRIER{
+            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        };
+        static constexpr VkMemoryBarrier WRITE_BARRIER{
+            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
+        };
+        const std::array pre_barriers{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = src_image,
+                .subresourceRange = src_range.SubresourceRange(src_aspect_mask),
+            },
+        };
+        const std::array middle_in_barrier{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                .dstAccessMask = 0,
+                .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = src_image,
+                .subresourceRange = src_range.SubresourceRange(src_aspect_mask),
+            },
+        };
+        const std::array middle_out_barrier{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = dst_image,
+                .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
+            },
+        };
+        const std::array post_barriers{
+            VkImageMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
+                                 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
+                                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = dst_image,
+                .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
+            },
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               0, {}, {}, pre_barriers);
+
+        cmdbuf.CopyImageToBuffer(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, copy_buffer,
+                                 vk_in_copies);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                               0, WRITE_BARRIER, nullptr, middle_in_barrier);
+
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               0, READ_BARRIER, {}, middle_out_barrier);
+        cmdbuf.CopyBufferToImage(copy_buffer, dst_image, VK_IMAGE_LAYOUT_GENERAL, vk_out_copies);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                               0, {}, {}, post_barriers);
+    });
+}
+
 void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst, ImageView& src,
                                     const Region2D& dst_region, const Region2D& src_region,
                                     Tegra::Engines::Fermi2D::Filter filter,
@@ -886,6 +1057,22 @@ void TextureCacheRuntime::ConvertImage(Framebuffer* dst, ImageView& dst_view, Im
             return blit_image_helper.ConvertD16ToR16(dst, src_view, up_scale, down_shift);
         }
         break;
+    case PixelFormat::A8B8G8R8_UNORM:
+    case PixelFormat::B8G8R8A8_UNORM:
+        if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
+            return blit_image_helper.ConvertD24S8ToABGR8(dst, src_view, up_scale, down_shift);
+        }
+        break;
+    case PixelFormat::B10G11R11_FLOAT:
+        if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
+            return blit_image_helper.ConvertD24S8ToB10G11R11(dst, src_view, up_scale, down_shift);
+        }
+        break;
+    case PixelFormat::R16G16_UNORM:
+        if (src_view.format == PixelFormat::S8_UINT_D24_UNORM) {
+            return blit_image_helper.ConvertD24S8ToR16G16(dst, src_view, up_scale, down_shift);
+        }
+        break;
     case PixelFormat::R32_FLOAT:
         if (src_view.format == PixelFormat::D32_FLOAT) {
             return blit_image_helper.ConvertD32ToR32(dst, src_view, up_scale, down_shift);
@@ -896,6 +1083,18 @@ void TextureCacheRuntime::ConvertImage(Framebuffer* dst, ImageView& dst_view, Im
             return blit_image_helper.ConvertR16ToD16(dst, src_view, up_scale, down_shift);
         }
         break;
+    case PixelFormat::S8_UINT_D24_UNORM:
+        if (src_view.format == PixelFormat::A8B8G8R8_UNORM ||
+            src_view.format == PixelFormat::B8G8R8A8_UNORM) {
+            return blit_image_helper.ConvertABGR8ToD24S8(dst, src_view, up_scale, down_shift);
+        }
+        if (src_view.format == PixelFormat::B10G11R11_FLOAT) {
+            return blit_image_helper.ConvertB10G11R11ToD24S8(dst, src_view, up_scale, down_shift);
+        }
+        if (src_view.format == PixelFormat::R16G16_UNORM) {
+            return blit_image_helper.ConvertR16G16ToD24S8(dst, src_view, up_scale, down_shift);
+        }
+        break;
     case PixelFormat::D32_FLOAT:
         if (src_view.format == PixelFormat::R32_FLOAT) {
             return blit_image_helper.ConvertR32ToD32(dst, src_view, up_scale, down_shift);

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -61,6 +61,10 @@ public:
 
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
+    bool ShouldReinterpret(Image& dst, Image& src);
+
+    void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+
     void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view, bool rescaled);
 
     bool CanAccelerateImageUpload(Image&) const noexcept {
@@ -82,6 +86,8 @@ public:
         return true;
     }
 
+    [[nodiscard]] VkBuffer GetTemporaryBuffer(size_t needed_size);
+
     const Device& device;
     VKScheduler& scheduler;
     MemoryAllocator& memory_allocator;
@@ -90,6 +96,10 @@ public:
     ASTCDecoderPass& astc_decoder_pass;
     RenderPassCache& render_pass_cache;
     const Settings::ResolutionScalingInfo& resolution;
+
+    constexpr static size_t indexing_slots = 8 * sizeof(size_t);
+    std::array<vk::Buffer, indexing_slots> buffers{};
+    std::array<std::unique_ptr<MemoryCommit>, indexing_slots> buffer_commits{};
 };
 
 class Image : public VideoCommon::ImageBase {

src/video_core/texture_cache/texture_cache.h

@@ -475,6 +475,7 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     const BlitImages images = GetBlitImages(dst, src);
     const ImageId dst_id = images.dst_id;
     const ImageId src_id = images.src_id;
+
     PrepareImage(src_id, false, false);
     PrepareImage(dst_id, true, false);
 
@@ -758,7 +759,8 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
             return ImageId{};
         }
     }
-    const bool broken_views = runtime.HasBrokenTextureViewFormats();
+    const bool broken_views =
+        runtime.HasBrokenTextureViewFormats() || True(options & RelaxedOptions::ForceBrokenViews);
     const bool native_bgr = runtime.HasNativeBgr();
     ImageId image_id;
     const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
@@ -1094,12 +1096,13 @@ typename TextureCache<P>::BlitImages TextureCache<P>::GetBlitImages(
         if (GetFormatType(dst_info.format) != GetFormatType(src_info.format)) {
             continue;
         }
-        if (!dst_id) {
-            dst_id = InsertImage(dst_info, dst_addr, RelaxedOptions{});
-        }
-        if (!src_id) {
-            src_id = InsertImage(src_info, src_addr, RelaxedOptions{});
+        RelaxedOptions find_options{};
+        if (src_info.num_samples > 1) {
+            // it's a resolve, we must enforce the same format.
+            find_options = RelaxedOptions::ForceBrokenViews;
         }
+        src_id = FindOrInsertImage(src_info, src_addr, find_options);
+        dst_id = FindOrInsertImage(dst_info, dst_addr, find_options);
     } while (has_deleted_images);
     return BlitImages{
         .dst_id = dst_id,
@@ -1759,6 +1762,9 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
     }
     UNIMPLEMENTED_IF(dst.info.type != ImageType::e2D);
     UNIMPLEMENTED_IF(src.info.type != ImageType::e2D);
+    if (runtime.ShouldReinterpret(dst, src)) {
+        return runtime.ReinterpretImage(dst, src, copies);
+    }
     for (const ImageCopy& copy : copies) {
         UNIMPLEMENTED_IF(copy.dst_subresource.num_layers != 1);
         UNIMPLEMENTED_IF(copy.src_subresource.num_layers != 1);

src/video_core/texture_cache/types.h

@@ -54,6 +54,7 @@ enum class RelaxedOptions : u32 {
     Size = 1 << 0,
     Format = 1 << 1,
     Samples = 1 << 2,
+    ForceBrokenViews = 1 << 3,
 };
 DECLARE_ENUM_FLAG_OPERATORS(RelaxedOptions)
 

src/video_core/texture_cache/util.cpp

@@ -1151,18 +1151,39 @@ bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src) {
-    if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
-        src_info.format = src->info.format;
+    bool is_resolve = false;
+    const auto original_src_format = src_info.format;
+    const auto original_dst_format = dst_info.format;
+    if (src) {
+        if (GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
+            src_info.format = src->info.format;
+        }
+        is_resolve = src->info.num_samples > 1;
+        src_info.num_samples = src->info.num_samples;
+        src_info.size = src->info.size;
     }
     if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
         dst_info.format = dst->info.format;
     }
     if (src && GetFormatType(src->info.format) != SurfaceType::ColorTexture) {
-        dst_info.format = src->info.format;
+        if (dst) {
+            if (GetFormatType(dst->info.format) == SurfaceType::ColorTexture) {
+                src_info.format = original_src_format;
+            }
+        } else {
+            dst_info.format = src->info.format;
+        }
     }
     if (dst && GetFormatType(dst->info.format) != SurfaceType::ColorTexture) {
-        src_info.format = dst->info.format;
+        if (src) {
+            if (GetFormatType(src->info.format) == SurfaceType::ColorTexture) {
+                dst_info.format = original_dst_format;
+            }
+        } else {
+            src_info.format = dst->info.format;
+        }
     }
+    ASSERT(!is_resolve || dst_info.format == src_info.format);
 }
 
 u32 MapSizeBytes(const ImageBase& image) {

src/video_core/video_core.cpp

@@ -55,10 +55,4 @@ std::unique_ptr<Tegra::GPU> CreateGPU(Core::Frontend::EmuWindow& emu_window, Cor
     }
 }
 
-float GetResolutionScaleFactor(const RendererBase& renderer) {
-    return Settings::values.resolution_info.active
-               ? Settings::values.resolution_info.up_factor
-               : renderer.GetRenderWindow().GetFramebufferLayout().GetScalingRatio();
-}
-
 } // namespace VideoCore

src/video_core/video_core.h

@@ -25,6 +25,4 @@ class RendererBase;
 /// Creates an emulated GPU instance using the given system context.
 std::unique_ptr<Tegra::GPU> CreateGPU(Core::Frontend::EmuWindow& emu_window, Core::System& system);
 
-float GetResolutionScaleFactor(const RendererBase& renderer);
-
 } // namespace VideoCore

src/yuzu/bootmanager.cpp

@@ -303,6 +303,7 @@ GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_,
     connect(this, &GRenderWindow::ExecuteProgramSignal, parent, &GMainWindow::OnExecuteProgram,
             Qt::QueuedConnection);
     connect(this, &GRenderWindow::ExitSignal, parent, &GMainWindow::OnExit, Qt::QueuedConnection);
+    connect(this, &GRenderWindow::TasPlaybackStateChanged, parent, &GMainWindow::OnTasStateChanged);
 }
 
 void GRenderWindow::ExecuteProgram(std::size_t program_index) {
@@ -319,10 +320,18 @@ GRenderWindow::~GRenderWindow() {
 
 void GRenderWindow::OnFrameDisplayed() {
     input_subsystem->GetTas()->UpdateThread();
+    const TasInput::TasState new_tas_state = std::get<0>(input_subsystem->GetTas()->GetStatus());
+
     if (!first_frame) {
+        last_tas_state = new_tas_state;
         first_frame = true;
         emit FirstFrameDisplayed();
     }
+
+    if (new_tas_state != last_tas_state) {
+        last_tas_state = new_tas_state;
+        emit TasPlaybackStateChanged();
+    }
 }
 
 bool GRenderWindow::IsShown() const {
@@ -630,7 +639,7 @@ void GRenderWindow::ReleaseRenderTarget() {
 
 void GRenderWindow::CaptureScreenshot(const QString& screenshot_path) {
     auto& renderer = system.Renderer();
-    const f32 res_scale = VideoCore::GetResolutionScaleFactor(renderer);
+    const f32 res_scale = Settings::values.resolution_info.up_factor;
 
     const Layout::FramebufferLayout layout{Layout::FrameLayoutFromResolutionScale(res_scale)};
     screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);

src/yuzu/bootmanager.h

@@ -41,6 +41,10 @@ enum class LoadCallbackStage;
 class RendererBase;
 } // namespace VideoCore
 
+namespace TasInput {
+enum class TasState;
+}
+
 class EmuThread final : public QThread {
     Q_OBJECT
 
@@ -203,6 +207,7 @@ signals:
     void ExecuteProgramSignal(std::size_t program_index);
     void ExitSignal();
     void MouseActivity();
+    void TasPlaybackStateChanged();
 
 private:
     void TouchBeginEvent(const QTouchEvent* event);
@@ -236,6 +241,7 @@ private:
     QWidget* child_widget = nullptr;
 
     bool first_frame = false;
+    TasInput::TasState last_tas_state;
 
     std::array<std::size_t, 16> touch_ids{};
 

src/yuzu/configuration/configure_graphics.ui

@@ -429,7 +429,7 @@
              </item>
              <item>
               <property name="text">
-               <string>AMD's FidelityFX™️ Super Resolution [Vulkan Only]</string>
+               <string>AMD FidelityFX™️ Super Resolution [Vulkan Only]</string>
               </property>
              </item>
             </widget>

src/yuzu/hotkeys.cpp

@@ -46,6 +46,8 @@ QShortcut* HotkeyRegistry::GetHotkey(const QString& group, const QString& action
     if (!hk.shortcut)
         hk.shortcut = new QShortcut(hk.keyseq, widget, nullptr, nullptr, hk.context);
 
+    hk.shortcut->setAutoRepeat(false);
+
     return hk.shortcut;
 }
 

src/yuzu/main.cpp

@@ -965,6 +965,9 @@ void GMainWindow::InitializeHotkeys() {
     const QString toggle_status_bar = QStringLiteral("Toggle Status Bar");
     const QString fullscreen = QStringLiteral("Fullscreen");
     const QString capture_screenshot = QStringLiteral("Capture Screenshot");
+    const QString tas_start_stop = QStringLiteral("TAS Start/Stop");
+    const QString tas_record = QStringLiteral("TAS Record");
+    const QString tas_reset = QStringLiteral("TAS Reset");
 
     ui->action_Load_File->setShortcut(hotkey_registry.GetKeySequence(main_window, load_file));
     ui->action_Load_File->setShortcutContext(
@@ -1005,6 +1008,18 @@ void GMainWindow::InitializeHotkeys() {
     ui->action_Fullscreen->setShortcutContext(
         hotkey_registry.GetShortcutContext(main_window, fullscreen));
 
+    ui->action_TAS_Start->setShortcut(hotkey_registry.GetKeySequence(main_window, tas_start_stop));
+    ui->action_TAS_Start->setShortcutContext(
+        hotkey_registry.GetShortcutContext(main_window, tas_start_stop));
+
+    ui->action_TAS_Record->setShortcut(hotkey_registry.GetKeySequence(main_window, tas_record));
+    ui->action_TAS_Record->setShortcutContext(
+        hotkey_registry.GetShortcutContext(main_window, tas_record));
+
+    ui->action_TAS_Reset->setShortcut(hotkey_registry.GetKeySequence(main_window, tas_reset));
+    ui->action_TAS_Reset->setShortcutContext(
+        hotkey_registry.GetShortcutContext(main_window, tas_reset));
+
     connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Load File"), this),
             &QShortcut::activated, this, &GMainWindow::OnMenuLoadFile);
     connect(
@@ -1031,7 +1046,7 @@ void GMainWindow::InitializeHotkeys() {
             &QShortcut::activatedAmbiguously, ui->action_Fullscreen, &QAction::trigger);
     connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Exit Fullscreen"), this),
             &QShortcut::activated, this, [&] {
-                if (emulation_running) {
+                if (emulation_running && ui->action_Fullscreen->isChecked()) {
                     ui->action_Fullscreen->setChecked(false);
                     ToggleFullscreen();
                 }
@@ -1095,28 +1110,6 @@ void GMainWindow::InitializeHotkeys() {
                     render_window->setAttribute(Qt::WA_Hover, true);
                 }
             });
-    connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("TAS Start/Stop"), this),
-            &QShortcut::activated, this, [&] {
-                if (!emulation_running) {
-                    return;
-                }
-                input_subsystem->GetTas()->StartStop();
-            });
-    connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("TAS Reset"), this),
-            &QShortcut::activated, this, [&] { input_subsystem->GetTas()->Reset(); });
-    connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("TAS Record"), this),
-            &QShortcut::activated, this, [&] {
-                if (!emulation_running) {
-                    return;
-                }
-                bool is_recording = input_subsystem->GetTas()->Record();
-                if (!is_recording) {
-                    const auto res = QMessageBox::question(this, tr("TAS Recording"),
-                                                           tr("Overwrite file of player 1?"),
-                                                           QMessageBox::Yes | QMessageBox::No);
-                    input_subsystem->GetTas()->SaveRecording(res == QMessageBox::Yes);
-                }
-            });
 }
 
 void GMainWindow::SetDefaultUIGeometry() {
@@ -1236,11 +1229,11 @@ void GMainWindow::ConnectMenuEvents() {
     connect(ui->action_Restart, &QAction::triggered, this,
             [this] { BootGame(QString(game_path)); });
     connect(ui->action_Configure, &QAction::triggered, this, &GMainWindow::OnConfigure);
-    connect(ui->action_Configure_Tas, &QAction::triggered, this, &GMainWindow::OnConfigureTas);
     connect(ui->action_Configure_Current_Game, &QAction::triggered, this,
             &GMainWindow::OnConfigurePerGame);
 
     // View
+    connect(ui->action_Fullscreen, &QAction::triggered, this, &GMainWindow::ToggleFullscreen);
     connect(ui->action_Single_Window_Mode, &QAction::triggered, this,
             &GMainWindow::ToggleWindowMode);
     connect(ui->action_Display_Dock_Widget_Headers, &QAction::triggered, this,
@@ -1258,17 +1251,20 @@ void GMainWindow::ConnectMenuEvents() {
     ui->menu_Reset_Window_Size->addAction(ui->action_Reset_Window_Size_900);
     ui->menu_Reset_Window_Size->addAction(ui->action_Reset_Window_Size_1080);
 
-    // Fullscreen
-    connect(ui->action_Fullscreen, &QAction::triggered, this, &GMainWindow::ToggleFullscreen);
-
-    // Movie
+    // Tools
+    connect(ui->action_Rederive, &QAction::triggered, this,
+            std::bind(&GMainWindow::OnReinitializeKeys, this, ReinitializeKeyBehavior::Warning));
     connect(ui->action_Capture_Screenshot, &QAction::triggered, this,
             &GMainWindow::OnCaptureScreenshot);
 
+    // TAS
+    connect(ui->action_TAS_Start, &QAction::triggered, this, &GMainWindow::OnTasStartStop);
+    connect(ui->action_TAS_Record, &QAction::triggered, this, &GMainWindow::OnTasRecord);
+    connect(ui->action_TAS_Reset, &QAction::triggered, this, &GMainWindow::OnTasReset);
+    connect(ui->action_Configure_Tas, &QAction::triggered, this, &GMainWindow::OnConfigureTas);
+
     // Help
     connect(ui->action_Open_yuzu_Folder, &QAction::triggered, this, &GMainWindow::OnOpenYuzuFolder);
-    connect(ui->action_Rederive, &QAction::triggered, this,
-            std::bind(&GMainWindow::OnReinitializeKeys, this, ReinitializeKeyBehavior::Warning));
     connect(ui->action_About, &QAction::triggered, this, &GMainWindow::OnAbout);
 }
 
@@ -1582,6 +1578,7 @@ void GMainWindow::ShutdownGame() {
     game_list->SetFilterFocus();
     tas_label->clear();
     input_subsystem->GetTas()->Stop();
+    OnTasStateChanged();
 
     render_window->removeEventFilter(render_window);
     render_window->setAttribute(Qt::WA_Hover, false);
@@ -2509,6 +2506,7 @@ void GMainWindow::OnStartGame() {
     ui->action_Restart->setEnabled(true);
     ui->action_Configure_Current_Game->setEnabled(true);
     ui->action_Report_Compatibility->setEnabled(true);
+    OnTasStateChanged();
 
     discord_rpc->Update();
     ui->action_Load_Amiibo->setEnabled(true);
@@ -2821,6 +2819,32 @@ void GMainWindow::OnConfigureTas() {
     }
 }
 
+void GMainWindow::OnTasStartStop() {
+    if (!emulation_running) {
+        return;
+    }
+    input_subsystem->GetTas()->StartStop();
+    OnTasStateChanged();
+}
+
+void GMainWindow::OnTasRecord() {
+    if (!emulation_running) {
+        return;
+    }
+    const bool is_recording = input_subsystem->GetTas()->Record();
+    if (!is_recording) {
+        const auto res =
+            QMessageBox::question(this, tr("TAS Recording"), tr("Overwrite file of player 1?"),
+                                  QMessageBox::Yes | QMessageBox::No);
+        input_subsystem->GetTas()->SaveRecording(res == QMessageBox::Yes);
+    }
+    OnTasStateChanged();
+}
+
+void GMainWindow::OnTasReset() {
+    input_subsystem->GetTas()->Reset();
+}
+
 void GMainWindow::OnConfigurePerGame() {
     const u64 title_id = system->GetCurrentProcessProgramID();
     OpenPerGameConfiguration(title_id, game_path.toStdString());
@@ -3014,6 +3038,23 @@ QString GMainWindow::GetTasStateDescription() const {
     }
 }
 
+void GMainWindow::OnTasStateChanged() {
+    bool is_running = false;
+    bool is_recording = false;
+    if (emulation_running) {
+        const TasInput::TasState tas_status = std::get<0>(input_subsystem->GetTas()->GetStatus());
+        is_running = tas_status == TasInput::TasState::Running;
+        is_recording = tas_status == TasInput::TasState::Recording;
+    }
+
+    ui->action_TAS_Start->setText(is_running ? tr("&Stop Running") : tr("&Start"));
+    ui->action_TAS_Record->setText(is_recording ? tr("Stop R&ecording") : tr("R&ecord"));
+
+    ui->action_TAS_Start->setEnabled(emulation_running);
+    ui->action_TAS_Record->setEnabled(emulation_running);
+    ui->action_TAS_Reset->setEnabled(emulation_running);
+}
+
 void GMainWindow::UpdateStatusBar() {
     if (emu_thread == nullptr) {
         status_bar_update_timer.stop();
@@ -3106,7 +3147,7 @@ void GMainWindow::UpdateFilterText() {
         filter_status_button->setText(tr("SCALEFORCE"));
         break;
     case Settings::ScalingFilter::Fsr:
-        filter_status_button->setText(tr("AMD'S FIDELITYFX SR"));
+        filter_status_button->setText(tr("FSR"));
         break;
     default:
         filter_status_button->setText(tr("BILINEAR"));
@@ -3117,15 +3158,15 @@ void GMainWindow::UpdateFilterText() {
 void GMainWindow::UpdateAAText() {
     const auto aa_mode = Settings::values.anti_aliasing.GetValue();
     switch (aa_mode) {
-    case Settings::AntiAliasing::Fxaa:
-        aa_status_button->setText(tr("FXAA"));
-        break;
     case Settings::AntiAliasing::None:
         aa_status_button->setText(tr("NO AA"));
         break;
-    default:
+    case Settings::AntiAliasing::Fxaa:
         aa_status_button->setText(tr("FXAA"));
         break;
+    default:
+        aa_status_button->setText(tr("NO AA"));
+        break;
     }
 }
 
@@ -3300,9 +3341,9 @@ void GMainWindow::OnReinitializeKeys(ReinitializeKeyBehavior behavior) {
         if (!errors.isEmpty()) {
             QMessageBox::warning(
                 this, tr("Derivation Components Missing"),
-                tr("Components are missing that may hinder key derivation from completing. "
+                tr("Encryption keys are missing. "
                    "<br>Please follow <a href='https://yuzu-emu.org/help/quickstart/'>the yuzu "
-                   "quickstart guide</a> to get all your keys and "
+                   "quickstart guide</a> to get all your keys, firmware and "
                    "games.<br><br><small>(%1)</small>")
                     .arg(errors));
         }

src/yuzu/main.h

@@ -177,6 +177,7 @@ public slots:
     void WebBrowserOpenWebPage(const std::string& main_url, const std::string& additional_args,
                                bool is_local);
     void OnAppFocusStateChanged(Qt::ApplicationState state);
+    void OnTasStateChanged();
 
 private:
     void RegisterMetaTypes();
@@ -268,6 +269,9 @@ private slots:
     void OnMenuRecentFile();
     void OnConfigure();
     void OnConfigureTas();
+    void OnTasStartStop();
+    void OnTasRecord();
+    void OnTasReset();
     void OnConfigurePerGame();
     void OnLoadAmiibo();
     void OnOpenYuzuFolder();
@@ -313,6 +317,7 @@ private:
     void OpenURL(const QUrl& url);
     void LoadTranslation();
     void OpenPerGameConfiguration(u64 title_id, const std::string& file_name);
+
     QString GetTasStateDescription() const;
 
     std::unique_ptr<Ui::MainWindow> ui;

src/yuzu/main.ui

@@ -79,39 +79,39 @@
      <string>&amp;View</string>
     </property>
     <widget class="QMenu" name="menu_Reset_Window_Size">
-      <property name="title">
-        <string>&amp;Reset Window Size</string>
-      </property>
+     <property name="title">
+      <string>&amp;Reset Window Size</string>
+     </property>
     </widget>
-    <action name="action_Reset_Window_Size_720">
-      <property name="text">
-        <string>Reset Window Size to &amp;720p</string>
-      </property>
-      <property name="iconText">
-        <string>Reset Window Size to 720p</string>
-      </property>
-    </action>
-    <action name="action_Reset_Window_Size_900">
-      <property name="text">
-        <string>Reset Window Size to &amp;900p</string>
-      </property>
-      <property name="iconText">
-        <string>Reset Window Size to 900p</string>
-      </property>
-    </action>
-    <action name="action_Reset_Window_Size_1080">
-      <property name="text">
-        <string>Reset Window Size to &amp;1080p</string>
-      </property>
-      <property name="iconText">
-        <string>Reset Window Size to 1080p</string>
-      </property>
-    </action>
     <widget class="QMenu" name="menu_View_Debugging">
      <property name="title">
       <string>&amp;Debugging</string>
      </property>
     </widget>
+    <action name="action_Reset_Window_Size_720">
+     <property name="text">
+      <string>Reset Window Size to &amp;720p</string>
+     </property>
+     <property name="iconText">
+      <string>Reset Window Size to 720p</string>
+     </property>
+    </action>
+    <action name="action_Reset_Window_Size_900">
+     <property name="text">
+      <string>Reset Window Size to &amp;900p</string>
+     </property>
+     <property name="iconText">
+      <string>Reset Window Size to 900p</string>
+     </property>
+    </action>
+    <action name="action_Reset_Window_Size_1080">
+     <property name="text">
+      <string>Reset Window Size to &amp;1080p</string>
+     </property>
+     <property name="iconText">
+      <string>Reset Window Size to 1080p</string>
+     </property>
+    </action>
     <addaction name="action_Fullscreen"/>
     <addaction name="action_Single_Window_Mode"/>
     <addaction name="action_Display_Dock_Widget_Headers"/>
@@ -125,10 +125,20 @@
     <property name="title">
      <string>&amp;Tools</string>
     </property>
+    <widget class="QMenu" name="menuTAS">
+     <property name="title">
+      <string>&amp;TAS</string>
+     </property>
+     <addaction name="action_TAS_Start"/>
+     <addaction name="action_TAS_Record"/>
+     <addaction name="action_TAS_Reset"/>
+     <addaction name="separator"/>
+     <addaction name="action_Configure_Tas"/>
+    </widget>
     <addaction name="action_Rederive"/>
     <addaction name="separator"/>
     <addaction name="action_Capture_Screenshot"/>
-    <addaction name="action_Configure_Tas"/>
+    <addaction name="menuTAS"/>
    </widget>
    <widget class="QMenu" name="menu_Help">
     <property name="title">
@@ -309,7 +319,7 @@
   </action>
   <action name="action_Configure_Tas">
    <property name="text">
-    <string>Configure &amp;TAS...</string>
+    <string>&amp;Configure TAS...</string>
    </property>
   </action>
   <action name="action_Configure_Current_Game">
@@ -320,6 +330,30 @@
     <string>Configure C&amp;urrent Game...</string>
    </property>
   </action>
+  <action name="action_TAS_Start">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Start</string>
+   </property>
+  </action>
+  <action name="action_TAS_Reset">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Reset</string>
+   </property>
+  </action>
+  <action name="action_TAS_Record">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>R&amp;ecord</string>
+   </property>
+  </action>
  </widget>
  <resources>
   <include location="yuzu.qrc"/>