21 files changed, 110 insertions, 168 deletions

diff --git a/src/common/host_memory.cpp b/src/common/host_memory.cpp
index 6661244cf..b44a44949 100644
--- a/src/common/host_memory.cpp
+++ b/src/common/host_memory.cpp
@@ -314,8 +314,8 @@ private:
     }
 
     void UntrackPlaceholder(boost::icl::separate_interval_set<size_t>::iterator it) {
-        placeholders.erase(it);
         placeholder_host_pointers.erase(it->lower());
+        placeholders.erase(it);
     }
 
     /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp
index 01ae1a567..35a53d36c 100644
--- a/src/core/file_sys/program_metadata.cpp
+++ b/src/core/file_sys/program_metadata.cpp
@@ -77,7 +77,7 @@ void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address
     aci_header.title_id = title_id;
     aci_file_access.permissions = filesystem_permissions;
     npdm_header.system_resource_size = system_resource_size;
-    aci_kernel_capabilities = std ::move(capabilities);
+    aci_kernel_capabilities = std::move(capabilities);
 }
 
 bool ProgramMetadata::Is64BitProgram() const {
diff --git a/src/core/hle/kernel/k_handle_table.cpp b/src/core/hle/kernel/k_handle_table.cpp
index 6a420d5b0..44d13169f 100644
--- a/src/core/hle/kernel/k_handle_table.cpp
+++ b/src/core/hle/kernel/k_handle_table.cpp
@@ -7,7 +7,7 @@
 namespace Kernel {
 
 KHandleTable::KHandleTable(KernelCore& kernel_) : kernel{kernel_} {}
-KHandleTable ::~KHandleTable() = default;
+KHandleTable::~KHandleTable() = default;
 
 ResultCode KHandleTable::Finalize() {
     // Get the table and clear our record of it.
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index c930996ab..8c363142c 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -106,7 +106,7 @@ void IAppletResource::DeactivateController(HidController controller) {
     controllers[static_cast<size_t>(controller)]->DeactivateController();
 }
 
-IAppletResource ::~IAppletResource() {
+IAppletResource::~IAppletResource() {
     system.CoreTiming().UnscheduleEvent(pad_update_event, 0);
     system.CoreTiming().UnscheduleEvent(motion_update_event, 0);
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
index a33e47d0b..789000294 100644
--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
@@ -16,7 +16,7 @@ namespace Service::Nvidia::Devices {
 
 nvdisp_disp0::nvdisp_disp0(Core::System& system_, std::shared_ptr<nvmap> nvmap_dev_)
     : nvdevice{system_}, nvmap_dev{std::move(nvmap_dev_)} {}
-nvdisp_disp0 ::~nvdisp_disp0() = default;
+nvdisp_disp0::~nvdisp_disp0() = default;
 
 NvResult nvdisp_disp0::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               std::vector<u8>& output) {
diff --git a/src/core/hle/service/time/system_clock_core.cpp b/src/core/hle/service/time/system_clock_core.cpp
index bd334bbef..5c2354cdd 100644
--- a/src/core/hle/service/time/system_clock_core.cpp
+++ b/src/core/hle/service/time/system_clock_core.cpp
@@ -13,7 +13,7 @@ SystemClockCore::SystemClockCore(SteadyClockCore& steady_clock_core_)
     context.steady_time_point.clock_source_id = steady_clock_core.GetClockSourceId();
 }
 
-SystemClockCore ::~SystemClockCore() = default;
+SystemClockCore::~SystemClockCore() = default;
 
 ResultCode SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
     posix_time = 0;
diff --git a/src/core/hle/service/time/time_zone_service.cpp b/src/core/hle/service/time/time_zone_service.cpp
index 5c3108768..3871e7316 100644
--- a/src/core/hle/service/time/time_zone_service.cpp
+++ b/src/core/hle/service/time/time_zone_service.cpp
@@ -10,8 +10,8 @@
 
 namespace Service::Time {
 
-ITimeZoneService ::ITimeZoneService(Core::System& system_,
-                                    TimeZone::TimeZoneContentManager& time_zone_manager_)
+ITimeZoneService::ITimeZoneService(Core::System& system_,
+                                   TimeZone::TimeZoneContentManager& time_zone_manager_)
     : ServiceFramework{system_, "ITimeZoneService"}, time_zone_content_manager{time_zone_manager_} {
     static const FunctionInfo functions[] = {
         {0, &ITimeZoneService::GetDeviceLocationName, "GetDeviceLocationName"},
diff --git a/src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp b/src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp
index 580063fa9..170db269a 100644
--- a/src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp
+++ b/src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp
@@ -58,8 +58,8 @@ void GetCbuf(EmitContext& ctx, std::string_view ret, const IR::Value& binding,
     const auto cbuf{fmt::format("{}_cbuf{}", ctx.stage_name, binding.U32())};
     const auto cbuf_cast{fmt::format("{}({}[{}]{{}})", cast, cbuf, index)};
     const auto extraction{num_bits == 32 ? cbuf_cast
-                                         : fmt ::format("bitfieldExtract({},int({}),{})", cbuf_cast,
-                                                        bit_offset, num_bits)};
+                                         : fmt::format("bitfieldExtract({},int({}),{})", cbuf_cast,
+                                                       bit_offset, num_bits)};
     if (!component_indexing_bug) {
         const auto result{fmt::format(fmt::runtime(extraction), swizzle)};
         ctx.Add("{}={};", ret, result);
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index 7bfd57369..d350c9b36 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -570,13 +570,12 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
     ForEachWrittenRange(*cpu_src_address, amount, mirror);
     // This subtraction in this order is important for overlapping copies.
     common_ranges.subtract(subtract_interval);
-    bool atleast_1_download = tmp_intervals.size() != 0;
-    for (const IntervalType add_interval : tmp_intervals) {
+    const bool has_new_downloads = tmp_intervals.size() != 0;
+    for (const IntervalType& add_interval : tmp_intervals) {
         common_ranges.add(add_interval);
     }
-
     runtime.CopyBuffer(dest_buffer, src_buffer, copies);
-    if (atleast_1_download) {
+    if (has_new_downloads) {
         dest_buffer.MarkRegionAsGpuModified(*cpu_dest_address, amount);
     }
     std::vector<u8> tmp_buffer(amount);
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index c7ec1eac9..67388d980 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -82,41 +82,41 @@ void MaxwellDMA::Launch() {
 }
 
 void MaxwellDMA::CopyPitchToPitch() {
-    // When `multi_line_enable` bit is disabled the copy is performed as if we were copying a 1D
-    // buffer of length `line_length_in`.
-    // Otherwise we copy a 2D image of dimensions (line_length_in, line_count).
-    auto& accelerate = rasterizer->AccessAccelerateDMA();
-    if (!regs.launch_dma.multi_line_enable) {
-        const bool is_buffer_clear = regs.launch_dma.remap_enable != 0 &&
-                                     regs.remap_const.dst_x == RemapConst::Swizzle::CONST_A;
-        // TODO: allow multisized components.
-        if (is_buffer_clear) {
-            ASSERT(regs.remap_const.component_size_minus_one == 3);
-            accelerate.BufferClear(regs.offset_out, regs.line_length_in, regs.remap_consta_value);
-            std::vector<u32> tmp_buffer(regs.line_length_in, regs.remap_consta_value);
-            memory_manager.WriteBlockUnsafe(regs.offset_out,
-                                            reinterpret_cast<u8*>(tmp_buffer.data()),
-                                            regs.line_length_in * sizeof(u32));
-            return;
-        }
-        UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
-        if (!accelerate.BufferCopy(regs.offset_in, regs.offset_out, regs.line_length_in)) {
-            std::vector<u8> tmp_buffer(regs.line_length_in);
-            memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(), regs.line_length_in);
-            memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(), regs.line_length_in);
+    // When `multi_line_enable` bit is enabled we copy a 2D image of dimensions
+    // (line_length_in, line_count).
+    // Otherwise the copy is performed as if we were copying a 1D buffer of length line_length_in.
+    const bool remap_enabled = regs.launch_dma.remap_enable != 0;
+    if (regs.launch_dma.multi_line_enable) {
+        UNIMPLEMENTED_IF(remap_enabled);
+
+        // Perform a line-by-line copy.
+        // We're going to take a subrect of size (line_length_in, line_count) from the source
+        // rectangle. There is no need to manually flush/invalidate the regions because CopyBlock
+        // does that for us.
+        for (u32 line = 0; line < regs.line_count; ++line) {
+            const GPUVAddr source_line = regs.offset_in + static_cast<size_t>(line) * regs.pitch_in;
+            const GPUVAddr dest_line = regs.offset_out + static_cast<size_t>(line) * regs.pitch_out;
+            memory_manager.CopyBlock(dest_line, source_line, regs.line_length_in);
         }
         return;
     }
-
-    UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
-
-    // Perform a line-by-line copy.
-    // We're going to take a subrect of size (line_length_in, line_count) from the source rectangle.
-    // There is no need to manually flush/invalidate the regions because CopyBlock does that for us.
-    for (u32 line = 0; line < regs.line_count; ++line) {
-        const GPUVAddr source_line = regs.offset_in + static_cast<size_t>(line) * regs.pitch_in;
-        const GPUVAddr dest_line = regs.offset_out + static_cast<size_t>(line) * regs.pitch_out;
-        memory_manager.CopyBlock(dest_line, source_line, regs.line_length_in);
+    // TODO: allow multisized components.
+    auto& accelerate = rasterizer->AccessAccelerateDMA();
+    const bool is_const_a_dst = regs.remap_const.dst_x == RemapConst::Swizzle::CONST_A;
+    const bool is_buffer_clear = remap_enabled && is_const_a_dst;
+    if (is_buffer_clear) {
+        ASSERT(regs.remap_const.component_size_minus_one == 3);
+        accelerate.BufferClear(regs.offset_out, regs.line_length_in, regs.remap_consta_value);
+        std::vector<u32> tmp_buffer(regs.line_length_in, regs.remap_consta_value);
+        memory_manager.WriteBlockUnsafe(regs.offset_out, reinterpret_cast<u8*>(tmp_buffer.data()),
+                                        regs.line_length_in * sizeof(u32));
+        return;
+    }
+    UNIMPLEMENTED_IF(remap_enabled);
+    if (!accelerate.BufferCopy(regs.offset_in, regs.offset_out, regs.line_length_in)) {
+        std::vector<u8> tmp_buffer(regs.line_length_in);
+        memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(), regs.line_length_in);
+        memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(), regs.line_length_in);
     }
 }
 
diff --git a/src/video_core/engines/maxwell_dma.h b/src/video_core/engines/maxwell_dma.h
index 9e457ae16..a04514425 100644
--- a/src/video_core/engines/maxwell_dma.h
+++ b/src/video_core/engines/maxwell_dma.h
@@ -175,7 +175,7 @@ public:
     static_assert(sizeof(LaunchDMA) == 4);
 
     struct RemapConst {
-        enum Swizzle : u32 {
+        enum class Swizzle : u32 {
             SRC_X = 0,
             SRC_Y = 1,
             SRC_Z = 2,
diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txt
index c9cff7450..20d748c12 100644
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -6,7 +6,6 @@ set(SHADER_FILES
     convert_float_to_depth.frag
     full_screen_triangle.vert
     opengl_copy_bc4.comp
-    opengl_copy_bgra.comp
     opengl_present.frag
     opengl_present.vert
     pitch_unswizzle.comp
diff --git a/src/video_core/host_shaders/opengl_copy_bgra.comp b/src/video_core/host_shaders/opengl_copy_bgra.comp
deleted file mode 100644
index 2571a4abf..000000000
--- a/src/video_core/host_shaders/opengl_copy_bgra.comp
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#version 430 core
-
-layout (local_size_x = 4, local_size_y = 4) in;
-
-layout(binding = 0, rgba8) readonly uniform image2DArray bgr_input;
-layout(binding = 1, rgba8) writeonly uniform image2DArray bgr_output;
-
-void main() {
-    vec4 color = imageLoad(bgr_input, ivec3(gl_GlobalInvocationID));
-    imageStore(bgr_output, ivec3(gl_GlobalInvocationID), color.bgra);
-}
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
index 07a995f7d..187a28e4d 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -147,8 +147,7 @@ void BufferCacheRuntime::CopyBuffer(Buffer& dst_buffer, Buffer& src_buffer,
 
 void BufferCacheRuntime::ClearBuffer(Buffer& dest_buffer, u32 offset, size_t size, u32 value) {
     glClearNamedBufferSubData(dest_buffer.Handle(), GL_R32UI, static_cast<GLintptr>(offset),
-                              static_cast<GLsizeiptr>(size / sizeof(u32)), GL_RED, GL_UNSIGNED_INT,
-                              &value);
+                              static_cast<GLsizeiptr>(size), GL_RED, GL_UNSIGNED_INT, &value);
 }
 
 void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index b0aee6cc1..54dae2c41 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -461,7 +461,7 @@ bool TextureCacheRuntime::CanImageBeCopied(const Image& dst, const Image& src) {
     if (dst.info.type == ImageType::e3D && dst.info.format == PixelFormat::BC4_UNORM) {
         return false;
     }
-    if (IsPixelFormatBGR(dst.info.format) || IsPixelFormatBGR(src.info.format)) {
+    if (IsPixelFormatBGR(dst.info.format) != IsPixelFormatBGR(src.info.format)) {
         return false;
     }
     return true;
@@ -473,7 +473,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)) {
-        util_shaders.CopyBGR(dst, src, copies);
+        bgr_copy_pass.CopyBGR(dst, src, copies);
     } else {
         UNREACHABLE();
     }
@@ -1112,4 +1112,37 @@ Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM
     framebuffer.handle = handle;
 }
 
+void BGRCopyPass::CopyBGR(Image& dst_image, Image& src_image,
+                          std::span<const VideoCommon::ImageCopy> copies) {
+    static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0};
+    const u32 requested_pbo_size =
+        std::max(src_image.unswizzled_size_bytes, dst_image.unswizzled_size_bytes);
+
+    if (bgr_pbo_size < requested_pbo_size) {
+        bgr_pbo.Create();
+        bgr_pbo_size = requested_pbo_size;
+        glNamedBufferData(bgr_pbo.handle, bgr_pbo_size, nullptr, GL_STREAM_COPY);
+    }
+    for (const ImageCopy& copy : copies) {
+        ASSERT(copy.src_offset == zero_offset);
+        ASSERT(copy.dst_offset == zero_offset);
+
+        // 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,
+                             copy.src_subresource.num_layers, src_image.GlFormat(),
+                             src_image.GlType(), static_cast<GLsizei>(bgr_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);
+    }
+}
+
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index 4a4f6301c..c498a8a8f 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -47,6 +47,19 @@ struct FormatProperties {
     bool is_compressed;
 };
 
+class BGRCopyPass {
+public:
+    BGRCopyPass() = default;
+    ~BGRCopyPass() = default;
+
+    void CopyBGR(Image& dst_image, Image& src_image,
+                 std::span<const VideoCommon::ImageCopy> copies);
+
+private:
+    OGLBuffer bgr_pbo;
+    size_t bgr_pbo_size{};
+};
+
 class TextureCacheRuntime {
     friend Framebuffer;
     friend Image;
@@ -118,6 +131,7 @@ private:
     const Device& device;
     StateTracker& state_tracker;
     UtilShaders util_shaders;
+    BGRCopyPass bgr_copy_pass;
 
     std::array<std::unordered_map<GLenum, FormatProperties>, 3> format_properties;
     bool has_broken_texture_view_formats = false;
@@ -162,6 +176,14 @@ public:
         return texture.handle;
     }
 
+    GLuint GlFormat() const noexcept {
+        return gl_format;
+    }
+
+    GLuint GlType() const noexcept {
+        return gl_type;
+    }
+
 private:
     void CopyBufferToImage(const VideoCommon::BufferImageCopy& copy, size_t buffer_offset);
 
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 672f94bfc..39158aa3e 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -52,7 +52,7 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> FORMAT_TAB
     {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                          // BC6H_UFLOAT
     {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                            // BC6H_SFLOAT
     {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                                // ASTC_2D_4X4_UNORM
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},                            // B8G8R8A8_UNORM
+    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},                 // B8G8R8A8_UNORM
     {GL_RGBA32F, GL_RGBA, GL_FLOAT},                                  // R32G32B32A32_FLOAT
     {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},                            // R32G32B32A32_SINT
     {GL_RG32F, GL_RG, GL_FLOAT},                                      // R32G32_FLOAT
@@ -81,7 +81,7 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> FORMAT_TAB
     {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                                // ASTC_2D_8X8_UNORM
     {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                                // ASTC_2D_8X5_UNORM
     {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                                // ASTC_2D_5X4_UNORM
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE},                     // B8G8R8A8_SRGB
+    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},          // B8G8R8A8_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},                         // BC1_RGBA_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},                         // BC2_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},                         // BC3_SRGB
diff --git a/src/video_core/renderer_opengl/util_shaders.cpp b/src/video_core/renderer_opengl/util_shaders.cpp
index 333f35a1c..897c380b3 100644
--- a/src/video_core/renderer_opengl/util_shaders.cpp
+++ b/src/video_core/renderer_opengl/util_shaders.cpp
@@ -14,7 +14,6 @@
 #include "video_core/host_shaders/block_linear_unswizzle_2d_comp.h"
 #include "video_core/host_shaders/block_linear_unswizzle_3d_comp.h"
 #include "video_core/host_shaders/opengl_copy_bc4_comp.h"
-#include "video_core/host_shaders/opengl_copy_bgra_comp.h"
 #include "video_core/host_shaders/pitch_unswizzle_comp.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
@@ -44,11 +43,6 @@ namespace {
 OGLProgram MakeProgram(std::string_view source) {
     return CreateProgram(source, GL_COMPUTE_SHADER);
 }
-
-size_t NumPixelsInCopy(const VideoCommon::ImageCopy& copy) {
-    return static_cast<size_t>(copy.extent.width * copy.extent.height *
-                               copy.src_subresource.num_layers);
-}
 } // Anonymous namespace
 
 UtilShaders::UtilShaders(ProgramManager& program_manager_)
@@ -56,7 +50,6 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       block_linear_unswizzle_2d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_2D_COMP)),
       block_linear_unswizzle_3d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_3D_COMP)),
       pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)),
-      copy_bgra_program(MakeProgram(OPENGL_COPY_BGRA_COMP)),
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)) {
     const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
     swizzle_table_buffer.Create();
@@ -255,43 +248,6 @@ void UtilShaders::CopyBC4(Image& dst_image, Image& src_image, std::span<const Im
     program_manager.RestoreGuestCompute();
 }
 
-void UtilShaders::CopyBGR(Image& dst_image, Image& src_image,
-                          std::span<const VideoCommon::ImageCopy> copies) {
-    static constexpr GLuint BINDING_INPUT_IMAGE = 0;
-    static constexpr GLuint BINDING_OUTPUT_IMAGE = 1;
-    static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0};
-    const u32 bytes_per_block = BytesPerBlock(dst_image.info.format);
-    switch (bytes_per_block) {
-    case 2:
-        // BGR565 copy
-        for (const ImageCopy& copy : copies) {
-            ASSERT(copy.src_offset == zero_offset);
-            ASSERT(copy.dst_offset == zero_offset);
-            bgr_copy_pass.Execute(dst_image, src_image, copy);
-        }
-        break;
-    case 4: {
-        // BGRA8 copy
-        program_manager.BindComputeProgram(copy_bgra_program.handle);
-        constexpr GLenum FORMAT = GL_RGBA8;
-        for (const ImageCopy& copy : copies) {
-            ASSERT(copy.src_offset == zero_offset);
-            ASSERT(copy.dst_offset == zero_offset);
-            glBindImageTexture(BINDING_INPUT_IMAGE, src_image.StorageHandle(),
-                               copy.src_subresource.base_level, GL_FALSE, 0, GL_READ_ONLY, FORMAT);
-            glBindImageTexture(BINDING_OUTPUT_IMAGE, dst_image.StorageHandle(),
-                               copy.dst_subresource.base_level, GL_FALSE, 0, GL_WRITE_ONLY, FORMAT);
-            glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth);
-        }
-        program_manager.RestoreGuestCompute();
-        break;
-    }
-    default:
-        UNREACHABLE();
-        break;
-    }
-}
-
 GLenum StoreFormat(u32 bytes_per_block) {
     switch (bytes_per_block) {
     case 1:
@@ -309,36 +265,4 @@ GLenum StoreFormat(u32 bytes_per_block) {
     return GL_R8UI;
 }
 
-void Bgr565CopyPass::Execute(const Image& dst_image, const Image& src_image,
-                             const ImageCopy& copy) {
-    if (CopyBufferCreationNeeded(copy)) {
-        CreateNewCopyBuffer(copy, GL_TEXTURE_2D_ARRAY, GL_RGB565);
-    }
-    // Copy from source to PBO
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
-    glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width);
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle);
-    glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                         copy.src_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
-                         static_cast<GLsizei>(bgr16_pbo_size), nullptr);
-
-    // Copy from PBO to destination in reverse order
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width);
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr16_pbo.handle);
-    glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                        copy.dst_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV,
-                        nullptr);
-}
-
-bool Bgr565CopyPass::CopyBufferCreationNeeded(const ImageCopy& copy) {
-    return bgr16_pbo_size < NumPixelsInCopy(copy) * sizeof(u16);
-}
-
-void Bgr565CopyPass::CreateNewCopyBuffer(const ImageCopy& copy, GLenum target, GLuint format) {
-    bgr16_pbo.Create();
-    bgr16_pbo_size = NumPixelsInCopy(copy) * sizeof(u16);
-    glNamedBufferData(bgr16_pbo.handle, bgr16_pbo_size, nullptr, GL_STREAM_COPY);
-}
-
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/util_shaders.h b/src/video_core/renderer_opengl/util_shaders.h
index ef881e35f..5de95ea7a 100644
--- a/src/video_core/renderer_opengl/util_shaders.h
+++ b/src/video_core/renderer_opengl/util_shaders.h
@@ -19,22 +19,6 @@ class ProgramManager;
 
 struct ImageBufferMap;
 
-class Bgr565CopyPass {
-public:
-    Bgr565CopyPass() = default;
-    ~Bgr565CopyPass() = default;
-
-    void Execute(const Image& dst_image, const Image& src_image,
-                 const VideoCommon::ImageCopy& copy);
-
-private:
-    [[nodiscard]] bool CopyBufferCreationNeeded(const VideoCommon::ImageCopy& copy);
-    void CreateNewCopyBuffer(const VideoCommon::ImageCopy& copy, GLenum target, GLuint format);
-
-    OGLBuffer bgr16_pbo;
-    size_t bgr16_pbo_size{};
-};
-
 class UtilShaders {
 public:
     explicit UtilShaders(ProgramManager& program_manager);
@@ -55,9 +39,6 @@ public:
     void CopyBC4(Image& dst_image, Image& src_image,
                  std::span<const VideoCommon::ImageCopy> copies);
 
-    void CopyBGR(Image& dst_image, Image& src_image,
-                 std::span<const VideoCommon::ImageCopy> copies);
-
 private:
     ProgramManager& program_manager;
 
@@ -67,10 +48,7 @@ private:
     OGLProgram block_linear_unswizzle_2d_program;
     OGLProgram block_linear_unswizzle_3d_program;
     OGLProgram pitch_unswizzle_program;
-    OGLProgram copy_bgra_program;
     OGLProgram copy_bc4_program;
-
-    Bgr565CopyPass bgr_copy_pass;
 };
 
 GLenum StoreFormat(u32 bytes_per_block);
diff --git a/src/yuzu/applets/qt_web_browser.cpp b/src/yuzu/applets/qt_web_browser.cpp
index 652d99570..7d433ca50 100644
--- a/src/yuzu/applets/qt_web_browser.cpp
+++ b/src/yuzu/applets/qt_web_browser.cpp
@@ -54,6 +54,9 @@ QtNXWebEngineView::QtNXWebEngineView(QWidget* parent, Core::System& system,
       input_interpreter(std::make_unique<InputInterpreter>(system)),
       default_profile{QWebEngineProfile::defaultProfile()},
       global_settings{QWebEngineSettings::globalSettings()} {
+    default_profile->setPersistentStoragePath(QString::fromStdString(Common::FS::PathToUTF8String(
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::YuzuDir) / "qtwebengine")));
+
     QWebEngineScript gamepad;
     QWebEngineScript window_nx;
 
diff --git a/src/yuzu/configuration/configure_profile_manager.cpp b/src/yuzu/configuration/configure_profile_manager.cpp
index ac849b01d..136614bf8 100644
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@@ -76,7 +76,7 @@ QString GetProfileUsernameFromUser(QWidget* parent, const QString& description_t
 }
 } // Anonymous namespace
 
-ConfigureProfileManager ::ConfigureProfileManager(QWidget* parent)
+ConfigureProfileManager::ConfigureProfileManager(QWidget* parent)
     : QWidget(parent), ui(new Ui::ConfigureProfileManager),
       profile_manager(std::make_unique<Service::Account::ProfileManager>()) {
     ui->setupUi(this);