license

externals/bc_decoder/bc_decoder.h

@@ -1,43 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright © 2022 Skyline Team and Contributors (https://github.com/skyline-emu/)
+// Copyright 2022 Skyline Team and Contributors (https://github.com/skyline-emu/)
 
 #pragma once
 
 #include <cstdint>
 
 namespace bcn {
-    /**
-     * @brief Decodes a BC1 encoded image to R8G8B8A8
-     */
-    void DecodeBc1(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC2 encoded image to R8G8B8A8
-     */
-    void DecodeBc2(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC3 encoded image to R8G8B8A8
-     */
-    void DecodeBc3(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC4 encoded image to R8
-     */
+    /// @brief Decodes a BC1 encoded image to R8G8B8A8
+    void DecodeBc1(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    /// @brief Decodes a BC2 encoded image to R8G8B8A8
+    void DecodeBc2(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    //// @brief Decodes a BC3 encoded image to R8G8B8A8
+    void DecodeBc3(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    /// @brief Decodes a BC4 encoded image to R8
     void DecodeBc4(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC5 encoded image to R8G8
-     */
+    //// @brief Decodes a BC5 encoded image to R8G8
     void DecodeBc5(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC6 encoded image to R16G16B16A16
-     */
+    //// @brief Decodes a BC6 encoded image to R16G16B16A16
     void DecodeBc6(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC7 encoded image to R8G8B8A8
-     */
-    void DecodeBc7(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
+    /// @brief Decodes a BC7 encoded image to R8G8B8A8
+    void DecodeBc7(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -31,6 +31,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
+    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
     RENDERER_DEBUG("debug"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -806,6 +806,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
+                    titleId = R.string.enable_gpu_buffer_readback,
+                    descriptionId = R.string.enable_gpu_buffer_readback_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -292,6 +292,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
             add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
+            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
 
             add(HeaderSetting(R.string.hacks))

src/android/app/src/main/res/values/strings.xml

@@ -503,6 +503,8 @@
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
+    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
+    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
 

src/core/hle/service/os/process.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#include <utility>
-
 #include "common/common_types.h"
 
 namespace Core {
@@ -30,15 +28,6 @@ public:
     inline explicit Process(Core::System& system) noexcept : m_system(system) {}
     inline ~Process() { this->Finalize(); }
 
-    Process(const Process&) = delete;
-    Process& operator=(const Process&) = delete;
-    Process& operator=(Process&&) = delete;
-    inline Process(Process&& other) noexcept
-        : m_system(other.m_system), m_process(std::exchange(other.m_process, nullptr)),
-          m_main_thread_stack_size(std::exchange(other.m_main_thread_stack_size, 0)),
-          m_main_thread_priority(std::exchange(other.m_main_thread_priority, 0)),
-          m_process_started(std::exchange(other.m_process_started, false)) {}
-
     bool Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result);
     void Finalize();
 

src/tests/common/host_memory.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,19 +15,12 @@ static constexpr auto PERMS = Common::MemoryPermission::ReadWrite;
 static constexpr auto HEAP = false;
 
 TEST_CASE("HostMemory: Initialize and deinitialize", "[common]") {
-    {
-        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-        REQUIRE(mem.BackingBasePointer() != nullptr);
-    }
-    {
-        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-        REQUIRE(mem.BackingBasePointer() != nullptr);
-    }
+    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
+    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
 }
 
 TEST_CASE("HostMemory: Simple map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x8000, 0x1000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -40,7 +30,6 @@ TEST_CASE("HostMemory: Simple map", "[common]") {
 
 TEST_CASE("HostMemory: Simple mirror map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
     mem.Map(0x8000, 0x4000, 0x1000, PERMS, HEAP);
 
@@ -52,7 +41,6 @@ TEST_CASE("HostMemory: Simple mirror map", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -64,7 +52,6 @@ TEST_CASE("HostMemory: Simple unmap", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -82,7 +69,6 @@ TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
 
 TEST_CASE("HostMemory: Nieche allocation", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x20000, PERMS, HEAP);
     mem.Unmap(0x0000, 0x4000, HEAP);
     mem.Map(0x1000, 0, 0x2000, PERMS, HEAP);
@@ -92,7 +78,6 @@ TEST_CASE("HostMemory: Nieche allocation", "[common]") {
 
 TEST_CASE("HostMemory: Full unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
     mem.Map(0x6000, 0, 0x16000, PERMS, HEAP);
@@ -100,7 +85,6 @@ TEST_CASE("HostMemory: Full unmap", "[common]") {
 
 TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
     mem.Map(0x2000, 0x80000, 0x4000, PERMS, HEAP);
@@ -108,7 +92,6 @@ TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x6000, 0x4000, HEAP);
     mem.Map(0x8000, 0, 0x2000, PERMS, HEAP);
@@ -116,7 +99,6 @@ TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x1b000, PERMS, HEAP);
     mem.Unmap(0x3000, 0x1c000, HEAP);
@@ -125,7 +107,6 @@ TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
 
 TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
@@ -134,7 +115,6 @@ TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to origin", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x4000, 0x4000, HEAP);
@@ -144,7 +124,6 @@ TEST_CASE("HostMemory: Unmap to origin", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to right", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
@@ -153,7 +132,6 @@ TEST_CASE("HostMemory: Unmap to right", "[common]") {
 
 TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -166,7 +144,6 @@ TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -181,7 +158,6 @@ TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -196,7 +172,6 @@ TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial sparse middle unmap and check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x2000, PERMS, HEAP);
     mem.Map(0x6000, 0x20000, 0x2000, PERMS, HEAP);
 

src/video_core/buffer_cache/buffer_cache.h

@@ -1619,36 +1619,35 @@ void BufferCache<P>::TouchBuffer(Buffer& buffer, BufferId buffer_id) noexcept {
 template <class P>
 bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 size) {
     upload_copies.clear();
-    u64 staging_offset = 0;
+    u64 total_size_bytes = 0;
     u64 largest_copy = 0;
-    DAddr buffer_start = buffer.CpuAddr();
-    auto push = [&](u64 start, u64 end) {
-        if (start >= end) {
-            return;
-        }
-        u64 sz = end - start;
-        upload_copies.push_back({
-            .src_offset = staging_offset,
-            .dst_offset = start - buffer_start,
-            .size = sz
+    const DAddr buffer_start = buffer.cpu_addr_cached;
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+        upload_copies.push_back(BufferCopy{
+            .src_offset = total_size_bytes,
+            .dst_offset = device_addr_out - buffer_start,
+            .size = range_size,
         });
-        staging_offset += sz;
-        largest_copy = (std::max)(largest_copy, sz);
-    };
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 addr, u64 range_size) {
-        u64 start = addr;
-        u64 end = addr + range_size;
-        gpu_modified_ranges.ForEachInRange(start, range_size, [&](u64 gstart, u64 gsize) {
-            u64 gend = gstart + gsize;
-            push(start, gstart);
-            start = (std::max)(start, gend);
-        });
-        push(start, end);
+        total_size_bytes += range_size;
+        largest_copy = (std::max)(largest_copy, range_size);
     });
-    if (upload_copies.empty()) {
+    if (total_size_bytes == 0) {
         return true;
     }
-    UploadMemory(buffer, staging_offset, largest_copy, std::span(upload_copies));
+    if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
+        u64 min_offset = (std::numeric_limits<u64>::max)();
+        u64 max_offset = 0;
+        for (const auto& copy : upload_copies) {
+            min_offset = (std::min)(min_offset, copy.dst_offset);
+            max_offset = (std::max)(max_offset, copy.dst_offset + copy.size);
+        }
+        const DAddr sync_addr = buffer.CpuAddr() + min_offset;
+        const u64 sync_size = max_offset - min_offset;
+        DownloadBufferMemory(buffer, sync_addr, sync_size);
+    }
+    const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
+    UploadMemory(buffer, total_size_bytes, largest_copy, copies_span);
+    any_buffer_uploaded = true;
     return false;
 }
 
@@ -1699,7 +1698,6 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
             u8* const src_pointer = staging_pointer.data() + copy.src_offset;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             device_memory.ReadBlockUnsafe(device_addr, src_pointer, copy.size);
-
             // Apply the staging offset
             copy.src_offset += upload_staging.offset;
         }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -492,14 +492,10 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
-        device.SupportsDynamicState3DepthClampEnable();
+    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
     dynamic_features.has_dynamic_state3_logic_op_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LogicOpEnable();
     dynamic_features.has_dynamic_state3_line_stipple_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LineStippleEnable();
 
     // VIDS: Independent toggle (not affected by dyna_state levels)

src/video_core/texture_cache/decode_bc.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -9,6 +9,7 @@
 #include <span>
 #include <bc_decoder.h>
 
+#include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/texture_cache/decode_bc.h"
 
@@ -22,11 +23,8 @@ using VideoCore::Surface::PixelFormat;
 constexpr bool IsSigned(PixelFormat pixel_format) {
     switch (pixel_format) {
     case PixelFormat::BC4_SNORM:
-    case PixelFormat::BC4_UNORM:
     case PixelFormat::BC5_SNORM:
-    case PixelFormat::BC5_UNORM:
     case PixelFormat::BC6H_SFLOAT:
-    case PixelFormat::BC6H_UFLOAT:
         return true;
     default:
         return false;
@@ -62,9 +60,28 @@ u32 ConvertedBytesPerBlock(VideoCore::Surface::PixelFormat pixel_format) {
     }
 }
 
-template <auto decompress, PixelFormat pixel_format>
-void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy,
-                      bool is_signed = false) {
+void DecompressBCn(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy, VideoCore::Surface::PixelFormat pixel_format) {
+    auto const f = [pixel_format]{
+        switch (pixel_format) {
+        case PixelFormat::BC1_RGBA_UNORM:
+        case PixelFormat::BC1_RGBA_SRGB: return &bcn::DecodeBc1;
+        case PixelFormat::BC2_UNORM:
+        case PixelFormat::BC2_SRGB: return &bcn::DecodeBc2;
+        case PixelFormat::BC3_UNORM:
+        case PixelFormat::BC3_SRGB: return &bcn::DecodeBc3;
+        case PixelFormat::BC4_SNORM:
+        case PixelFormat::BC4_UNORM: return &bcn::DecodeBc4;
+        case PixelFormat::BC5_SNORM:
+        case PixelFormat::BC5_UNORM: return &bcn::DecodeBc5;
+        case PixelFormat::BC6H_SFLOAT:
+        case PixelFormat::BC6H_UFLOAT: return &bcn::DecodeBc6;
+        case PixelFormat::BC7_SRGB:
+        case PixelFormat::BC7_UNORM: return &bcn::DecodeBc7;
+        default:
+            UNREACHABLE_MSG("Unimplemented BCn decompression {}", pixel_format);
+            return &bcn::DecodeBc1;
+        }
+    }();
     const u32 out_bpp = ConvertedBytesPerBlock(pixel_format);
     const u32 block_size = BlockSize(pixel_format);
     const u32 width = copy.image_extent.width;
@@ -82,11 +99,7 @@ void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferIma
             for (u32 x = 0; x < width; x += block_width) {
                 const u8* src = input.data() + src_offset;
                 u8* const dst = output.data() + dst_offset;
-                if constexpr (IsSigned(pixel_format)) {
-                    decompress(src, dst, x, y, width, height, is_signed);
-                } else {
-                    decompress(src, dst, x, y, width, height);
-                }
+                f(src, dst, x, y, width, height, IsSigned(pixel_format));
                 src_offset += block_size;
                 dst_offset += block_width * out_bpp;
             }
@@ -96,43 +109,4 @@ void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferIma
     }
 }
 
-void DecompressBCn(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy,
-                   VideoCore::Surface::PixelFormat pixel_format) {
-    switch (pixel_format) {
-    case PixelFormat::BC1_RGBA_UNORM:
-    case PixelFormat::BC1_RGBA_SRGB:
-        DecompressBlocks<bcn::DecodeBc1, PixelFormat::BC1_RGBA_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC2_UNORM:
-    case PixelFormat::BC2_SRGB:
-        DecompressBlocks<bcn::DecodeBc2, PixelFormat::BC2_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC3_UNORM:
-    case PixelFormat::BC3_SRGB:
-        DecompressBlocks<bcn::DecodeBc3, PixelFormat::BC3_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC4_SNORM:
-    case PixelFormat::BC4_UNORM:
-        DecompressBlocks<bcn::DecodeBc4, PixelFormat::BC4_UNORM>(
-            input, output, copy, pixel_format == PixelFormat::BC4_SNORM);
-        break;
-    case PixelFormat::BC5_SNORM:
-    case PixelFormat::BC5_UNORM:
-        DecompressBlocks<bcn::DecodeBc5, PixelFormat::BC5_UNORM>(
-            input, output, copy, pixel_format == PixelFormat::BC5_SNORM);
-        break;
-    case PixelFormat::BC6H_SFLOAT:
-    case PixelFormat::BC6H_UFLOAT:
-        DecompressBlocks<bcn::DecodeBc6, PixelFormat::BC6H_UFLOAT>(
-            input, output, copy, pixel_format == PixelFormat::BC6H_SFLOAT);
-        break;
-    case PixelFormat::BC7_SRGB:
-    case PixelFormat::BC7_UNORM:
-        DecompressBlocks<bcn::DecodeBc7, PixelFormat::BC7_UNORM>(input, output, copy);
-        break;
-    default:
-        LOG_WARNING(HW_GPU, "Unimplemented BCn decompression {}", pixel_format);
-    }
-}
-
 } // namespace VideoCommon

src/video_core/texture_cache/util.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -922,8 +922,7 @@ boost::container::small_vector<BufferImageCopy, 16> UnswizzleImage(Tegra::Memory
     return copies;
 }
 
-void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8> output,
-                  std::span<BufferImageCopy> copies) {
+void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8> output, std::span<BufferImageCopy> copies) {
     u32 output_offset = 0;
     Common::ScratchBuffer<u8> decode_scratch;
 
@@ -955,10 +954,10 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
         } else if (astc) {
             // BC1 uses 0.5 bytes per texel
             // BC3 uses 1 byte per texel
-            const auto compress = recompression_setting == Settings::AstcRecompression::Bc1
-                                      ? Tegra::Texture::BCN::CompressBC1
-                                      : Tegra::Texture::BCN::CompressBC3;
-            const auto bpp_div = recompression_setting == Settings::AstcRecompression::Bc1 ? 2 : 1;
+            auto const compress = recompression_setting == Settings::AstcRecompression::Bc1
+                ? Tegra::Texture::BCN::CompressBC1
+                : Tegra::Texture::BCN::CompressBC3;
+            const auto bpp_div = compress == Tegra::Texture::BCN::CompressBC1 ? 2 : 1;
 
             const u32 plane_dim = copy.image_extent.width * copy.image_extent.height;
             const u32 level_size = plane_dim * copy.image_extent.depth *
@@ -975,18 +974,12 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
                      copy.image_subresource.num_layers * copy.image_extent.depth,
                      output.subspan(output_offset));
 
-            const u32 aligned_plane_dim = Common::AlignUp(copy.image_extent.width, 4) *
-                                          Common::AlignUp(copy.image_extent.height, 4);
-
-            copy.buffer_size =
-                (aligned_plane_dim * copy.image_extent.depth * copy.image_subresource.num_layers) /
-                bpp_div;
-            output_offset += static_cast<u32>(copy.buffer_size);
+            const u32 aligned_plane_dim = Common::AlignUp(copy.image_extent.width, 4) * Common::AlignUp(copy.image_extent.height, 4);
+            copy.buffer_size = (aligned_plane_dim * copy.image_extent.depth * copy.image_subresource.num_layers) / bpp_div;
+            output_offset += u32(copy.buffer_size);
         } else {
             DecompressBCn(input_offset, output.subspan(output_offset), copy, info.format);
-            output_offset += copy.image_extent.width * copy.image_extent.height *
-                             copy.image_subresource.num_layers *
-                             ConvertedBytesPerBlock(info.format);
+            output_offset += copy.image_extent.width * copy.image_extent.height * copy.image_subresource.num_layers * ConvertedBytesPerBlock(info.format);
         }
 
         copy.buffer_row_length = mip_size.width;