slug you

Signed-off-by: lizzie <lizzie@eden-emu.dev>

.patch/cpp-jwt/0001-fix-missing-decl.patch

@@ -0,0 +1,25 @@
+From ce992811fe8eb5ea7ad37e5b255bfecb0c313928 Mon Sep 17 00:00:00 2001
+From: crueter <crueter@crueter.xyz>
+Date: Sun, 7 Sep 2025 23:43:57 -0400
+Subject: [PATCH] [algorithm] fix missing declaration error
+
+Projects with restrictive error options won't compile without this
+
+Signed-off-by: crueter <crueter@crueter.xyz>
+---
+ include/jwt/algorithm.hpp | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/include/jwt/algorithm.hpp b/include/jwt/algorithm.hpp
+index 0e3b843..35347fe 100644
+--- a/include/jwt/algorithm.hpp
++++ b/include/jwt/algorithm.hpp
+@@ -63,6 +63,8 @@ using sign_func_t   = sign_result_t (*) (const jwt::string_view key,
+ using verify_func_t = verify_result_t (*) (const jwt::string_view key,
+                                            const jwt::string_view head,
+                                            const jwt::string_view jwt_sign);
++										   
++verify_result_t is_secret_a_public_key(const jwt::string_view secret);
+ 
+ namespace algo {
+ 

.patch/opus/0001-disable-clang-runtime-neon.patch

@@ -0,0 +1,28 @@
+From cc15da16e533b2a801934eab2dfeaf3c3949a1dc Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Mon, 8 Sep 2025 12:28:55 -0400
+Subject: [PATCH] [cmake] disable NEON runtime check on clang-cl
+
+When enabling runtime NEON checking for clang-cl, the linker would error out with `undefined symbol: __emit`, since clang doesn't actually implement this instruction. Therefore it makes sense to disable the runtime check by default on this platform, until either this is fixed or a clang-cl compatible intrinsic check is added (I don't have enough knowledge of MSVC to do this)
+---
+ cmake/OpusConfig.cmake | 7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+diff --git a/cmake/OpusConfig.cmake b/cmake/OpusConfig.cmake
+index e9319fbad..d0f459e88 100644
+--- a/cmake/OpusConfig.cmake
++++ b/cmake/OpusConfig.cmake
+@@ -71,7 +71,12 @@ elseif(OPUS_CPU_ARM AND NOT OPUS_DISABLE_INTRINSICS)
+   opus_detect_neon(COMPILER_SUPPORT_NEON)
+   if(COMPILER_SUPPORT_NEON)
+     option(OPUS_USE_NEON "Option to enable NEON" ON)
+-    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ON)
++    if (MSVC AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
++      set(NEON_RUNTIME_CHECK_DEFAULT OFF)
++    else()
++      set(NEON_RUNTIME_CHECK_DEFAULT ON)
++    endif()
++    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ${NEON_RUNTIME_CHECK_DEFAULT})
+     option(OPUS_PRESUME_NEON "Assume target CPU has NEON support" OFF)
+     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+       set(OPUS_PRESUME_NEON ON)

.patch/opus/0002-no-install.patch

@@ -0,0 +1,153 @@
+From bf455b67b4eaa446ffae5d25410b141b7b1b1082 Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Mon, 8 Sep 2025 12:08:20 -0400
+Subject: [PATCH] [cmake] `OPUS_INSTALL` option; only default install if root
+ project
+
+Signed-off-by: crueter <crueter@eden-emu.dev>
+---
+ CMakeLists.txt | 112 ++++++++++++++++++++++++++++---------------------
+ 1 file changed, 64 insertions(+), 48 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index fcf034b19..08b5e16f8 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -4,6 +4,13 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+ include(OpusPackageVersion)
+ get_package_version(PACKAGE_VERSION PROJECT_VERSION)
+ 
++# root project detection
++if(DEFINED PROJECT_NAME)
++  set(root_project OFF)
++else()
++  set(root_project ON)
++endif()
++
+ project(Opus LANGUAGES C VERSION ${PROJECT_VERSION})
+ 
+ include(OpusFunctions)
+@@ -83,12 +90,16 @@ set(OPUS_DNN_FLOAT_DEBUG_HELP_STR "Run DNN computations as float for debugging p
+ option(OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR} OFF)
+ add_feature_info(OPUS_DNN_FLOAT_DEBUG OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR})
+ 
++set(OPUS_INSTALL_HELP_STR "Install Opus targets")
++option(OPUS_INSTALL ${OPUS_INSTALL_HELP_STR} ${root_project})
++add_feature_info(OPUS_INSTALL OPUS_INSTALL ${OPUS_INSTALL_HELP_STR})
++
+ set(OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR "install pkg-config module.")
+-option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ON)
++option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
+ add_feature_info(OPUS_INSTALL_PKG_CONFIG_MODULE OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR})
+ 
+ set(OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR "install CMake package config module.")
+-option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ON)
++option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
+ add_feature_info(OPUS_INSTALL_CMAKE_CONFIG_MODULE OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR})
+ 
+ set(OPUS_DRED_HELP_STR "enable DRED.")
+@@ -613,53 +624,58 @@ if(OPUS_BUILD_FRAMEWORK)
+                         OUTPUT_NAME Opus)
+ endif()
+ 
+-install(TARGETS opus
+-        EXPORT OpusTargets
+-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+-        FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
+-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
+-
+-if(OPUS_INSTALL_PKG_CONFIG_MODULE)
+-  set(prefix ${CMAKE_INSTALL_PREFIX})
+-  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+-  set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
+-  set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
+-  set(VERSION ${PACKAGE_VERSION})
+-  if(HAVE_LIBM)
+-    set(LIBM "-lm")
++if (OPUS_INSTALL)
++  install(TARGETS opus
++          EXPORT OpusTargets
++          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
++          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
++          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
++          FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
++          PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
++
++  if(OPUS_INSTALL_PKG_CONFIG_MODULE)
++    set(prefix ${CMAKE_INSTALL_PREFIX})
++    set(exec_prefix ${CMAKE_INSTALL_PREFIX})
++    set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
++    set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
++    set(VERSION ${PACKAGE_VERSION})
++    if(HAVE_LIBM)
++      set(LIBM "-lm")
++    endif()
++    configure_file(opus.pc.in opus.pc)
++    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
++            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
++  endif()
++
++  if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
++    set(CPACK_GENERATOR TGZ)
++    include(CPack)
++    set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
++    install(EXPORT OpusTargets
++            NAMESPACE Opus::
++            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
++
++    include(CMakePackageConfigHelpers)
++
++    set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
++    configure_package_config_file(
++      ${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
++      OpusConfig.cmake
++      INSTALL_DESTINATION
++      ${CMAKE_INSTALL_PACKAGEDIR}
++      PATH_VARS
++      INCLUDE_INSTALL_DIR
++      INSTALL_PREFIX
++      ${CMAKE_INSTALL_PREFIX})
++
++    write_basic_package_version_file(OpusConfigVersion.cmake
++                                    VERSION ${PROJECT_VERSION}
++                                    COMPATIBILITY SameMajorVersion)
++
++    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
++                  ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
++            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
+   endif()
+-  configure_file(opus.pc.in opus.pc)
+-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
+-          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+-endif()
+-
+-if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
+-  set(CPACK_GENERATOR TGZ)
+-  include(CPack)
+-  set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+-  install(EXPORT OpusTargets
+-          NAMESPACE Opus::
+-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
+-
+-  include(CMakePackageConfigHelpers)
+-
+-  set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
+-  configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
+-                                OpusConfig.cmake
+-                                INSTALL_DESTINATION
+-                                ${CMAKE_INSTALL_PACKAGEDIR}
+-                                PATH_VARS
+-                                INCLUDE_INSTALL_DIR
+-                                INSTALL_PREFIX
+-                                ${CMAKE_INSTALL_PREFIX})
+-  write_basic_package_version_file(OpusConfigVersion.cmake
+-                                   VERSION ${PROJECT_VERSION}
+-                                   COMPATIBILITY SameMajorVersion)
+-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
+-                ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
+-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
+ endif()
+ 
+ if(OPUS_BUILD_PROGRAMS)

cpmfile.json

@@ -69,13 +69,17 @@
     },
     "opus": {
         "package": "Opus",
-        "repo": "crueter/opus",
-        "sha": "ab19c44fad",
-        "hash": "d632e8f83c5d3245db404bcb637113f9860bf16331498ba2c8e77979d1febee6b52d8b1da448e7d54eeac373e912cd55e3e300fc6c242244923323280dc43fbe",
+        "repo": "xiph/opus",
+        "sha": "a3f0ec02b3",
+        "hash": "9506147b0de35befda8633ff272981cc2575c860874791bd455b752f797fd7dbd1079f0ba42ccdd7bb1fe6773fa5e84b3d75667c2883dd1fb2d0e4a5fa4f8387",
         "version": "1.3",
         "find_args": "MODULE",
         "options": [
             "OPUS_PRESUME_NEON ON"
+        ],
+        "patches": [
+            "0001-disable-clang-runtime-neon.patch",
+            "0002-no-install.patch"
         ]
     },
     "boost_headers": {

externals/cpmfile.json

@@ -37,12 +37,15 @@
     },
     "cpp-jwt": {
         "version": "1.4",
-        "repo": "crueter/cpp-jwt",
-        "sha": "9eaea6328f",
-        "hash": "35b0b2bfb143585c7b2bd6dc6ca7df5ae5c6e2681000b2ebca077b0ac4bc1e6b6afbe1ce8e47f6d2edad12fcc6404f677acc2ad205661d819b8821ce6f4823fd",
+        "repo": "arun11299/cpp-jwt",
+        "sha": "7f24eb4c32",
+        "hash": "d11cbd5ddb3197b4c5ca15679bcd76a49963e7b530b7dd132db91e042925efa20dfb2c24ccfbe7ef82a7012af80deff0f72ee25851312ae80381a462df8534b8",
         "find_args": "CONFIG",
         "options": [
             "CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF"
+        ],
+        "patches": [
+            "0001-fix-missing-decl.patch"
         ]
     },
     "xbyak_sun": {
@@ -126,7 +129,7 @@
     },
     "spirv-tools": {
         "package": "SPIRV-Tools",
-        "repo": "crueter/SPIRV-Tools",
+        "repo": "KhronosGroup/SPIRV-Tools",
         "sha": "0a7e28689a",
         "hash": "eadfcceb82f4b414528d99962335e4f806101168474028f3cf7691ac40c37f323decf2a42c525e2d5bfa6f14ff132d6c5cf9b87c151490efad01f5e13ade1520",
         "git_version": "2025.4",

src/video_core/CMakeLists.txt

@@ -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: 2018 yuzu Emulator Project
@@ -37,10 +37,6 @@ add_library(video_core STATIC
     dirty_flags.h
     dma_pusher.cpp
     dma_pusher.h
-    engines/sw_blitter/blitter.cpp
-    engines/sw_blitter/blitter.h
-    engines/sw_blitter/converter.cpp
-    engines/sw_blitter/converter.h
     engines/const_buffer_info.h
     engines/draw_manager.cpp
     engines/draw_manager.h

src/video_core/engines/fermi_2d.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 2018 yuzu Emulator Project
@@ -7,7 +7,6 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "video_core/engines/fermi_2d.h"
-#include "video_core/engines/sw_blitter/blitter.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/surface.h"
@@ -21,7 +20,6 @@ namespace Tegra::Engines {
 using namespace Texture;
 
 Fermi2D::Fermi2D(MemoryManager& memory_manager_) : memory_manager{memory_manager_} {
-    sw_blitter = std::make_unique<Blitter::SoftwareBlitEngine>(memory_manager);
     // Nvidia's OpenGL driver seems to assume these values
     regs.src.depth = 1;
     regs.dst.depth = 1;
@@ -60,21 +58,19 @@ void Fermi2D::ConsumeSinkImpl() {
 }
 
 void Fermi2D::Blit() {
-    LOG_DEBUG(HW_GPU, "called. source address=0x{:x}, destination address=0x{:x}",
-              regs.src.Address(), regs.dst.Address());
+    LOG_DEBUG(HW_GPU, "called. source address=0x{:x}, destination address=0x{:x}", regs.src.Address(), regs.dst.Address());
+
+    const auto& args = regs.pixels_from_memory;
+    //constexpr s64 null_derivative = 1ULL << 32;
+    Surface src = regs.src;
+    const auto bytes_per_pixel = BytesPerBlock(PixelFormatFromRenderTargetFormat(src.format));
 
     UNIMPLEMENTED_IF_MSG(regs.operation != Operation::SrcCopy, "Operation is not copy");
     UNIMPLEMENTED_IF_MSG(regs.src.layer != 0, "Source layer is not zero");
     UNIMPLEMENTED_IF_MSG(regs.dst.layer != 0, "Destination layer is not zero");
     UNIMPLEMENTED_IF_MSG(regs.src.depth != 1, "Source depth is not one");
     UNIMPLEMENTED_IF_MSG(regs.clip_enable != 0, "Clipped blit enabled");
-
-    const auto& args = regs.pixels_from_memory;
-    constexpr s64 null_derivative = 1ULL << 32;
-    Surface src = regs.src;
-    const auto bytes_per_pixel = BytesPerBlock(PixelFormatFromRenderTargetFormat(src.format));
-    const bool delegate_to_gpu = src.width > 512 && src.height > 512 && bytes_per_pixel <= 8 &&
-                                 src.format != regs.dst.format;
+    // UNIMPLEMENTED_IF_MSG(args.du_dx == null_derivative && args.dv_dy == null_derivative, "du/dx & dv/dy null derivative");
 
     auto srcX = args.src_x0;
     auto srcY = args.src_y0;
@@ -86,8 +82,7 @@ void Fermi2D::Blit() {
     Config config{
         .operation = regs.operation,
         .filter = args.sample_mode.filter,
-        .must_accelerate =
-            args.du_dx != null_derivative || args.dv_dy != null_derivative || delegate_to_gpu,
+        .must_accelerate = true,
         .dst_x0 = args.dst_x0,
         .dst_y0 = args.dst_y0,
         .dst_x1 = args.dst_x0 + args.dst_width,
@@ -112,9 +107,9 @@ void Fermi2D::Blit() {
     }
 
     memory_manager.FlushCaching();
-    if (!rasterizer->AccelerateSurfaceCopy(src, regs.dst, config)) {
-        sw_blitter->Blit(src, regs.dst, config);
-    }
+
+    bool was_accelerated = rasterizer->AccelerateSurfaceCopy(src, regs.dst, config);
+    ASSERT(was_accelerated && "Backend must always accelerate copies/blits");
 }
 
 } // namespace Tegra::Engines

src/video_core/engines/fermi_2d.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -304,7 +307,6 @@ public:
 
 private:
     VideoCore::RasterizerInterface* rasterizer = nullptr;
-    std::unique_ptr<Blitter::SoftwareBlitEngine> sw_blitter;
     MemoryManager& memory_manager;
 
     /// Performs the copy from the source surface to the destination surface as configured in the

src/video_core/engines/sw_blitter/blitter.cpp

@@ -1,240 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <algorithm>
-#include <cmath>
-#include <vector>
-
-#include "common/scratch_buffer.h"
-#include "video_core/engines/sw_blitter/blitter.h"
-#include "video_core/engines/sw_blitter/converter.h"
-#include "video_core/guest_memory.h"
-#include "video_core/memory_manager.h"
-#include "video_core/surface.h"
-#include "video_core/textures/decoders.h"
-
-namespace Tegra {
-class MemoryManager;
-}
-
-using VideoCore::Surface::BytesPerBlock;
-using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
-
-namespace Tegra::Engines::Blitter {
-
-using namespace Texture;
-
-namespace {
-
-constexpr size_t ir_components = 4;
-
-void NearestNeighbor(std::span<const u8> input, std::span<u8> output, u32 src_width, u32 src_height,
-                     u32 dst_width, u32 dst_height, size_t bpp) {
-    const size_t dx_du = std::llround((static_cast<f64>(src_width) / dst_width) * (1ULL << 32));
-    const size_t dy_dv = std::llround((static_cast<f64>(src_height) / dst_height) * (1ULL << 32));
-    size_t src_y = 0;
-    for (u32 y = 0; y < dst_height; y++) {
-        size_t src_x = 0;
-        for (u32 x = 0; x < dst_width; x++) {
-            const size_t read_from = ((src_y * src_width + src_x) >> 32) * bpp;
-            const size_t write_to = (y * dst_width + x) * bpp;
-
-            std::memcpy(&output[write_to], &input[read_from], bpp);
-            src_x += dx_du;
-        }
-        src_y += dy_dv;
-    }
-}
-
-void NearestNeighborFast(std::span<const f32> input, std::span<f32> output, u32 src_width,
-                         u32 src_height, u32 dst_width, u32 dst_height) {
-    const size_t dx_du = std::llround((static_cast<f64>(src_width) / dst_width) * (1ULL << 32));
-    const size_t dy_dv = std::llround((static_cast<f64>(src_height) / dst_height) * (1ULL << 32));
-    size_t src_y = 0;
-    for (u32 y = 0; y < dst_height; y++) {
-        size_t src_x = 0;
-        for (u32 x = 0; x < dst_width; x++) {
-            const size_t read_from = ((src_y * src_width + src_x) >> 32) * ir_components;
-            const size_t write_to = (y * dst_width + x) * ir_components;
-
-            std::memcpy(&output[write_to], &input[read_from], sizeof(f32) * ir_components);
-            src_x += dx_du;
-        }
-        src_y += dy_dv;
-    }
-}
-
-void Bilinear(std::span<const f32> input, std::span<f32> output, size_t src_width,
-              size_t src_height, size_t dst_width, size_t dst_height) {
-    const auto bilinear_sample = [](std::span<const f32> x0_y0, std::span<const f32> x1_y0,
-                                    std::span<const f32> x0_y1, std::span<const f32> x1_y1,
-                                    f32 weight_x, f32 weight_y) {
-        std::array<f32, ir_components> result{};
-        for (size_t i = 0; i < ir_components; i++) {
-            const f32 a = std::lerp(x0_y0[i], x1_y0[i], weight_x);
-            const f32 b = std::lerp(x0_y1[i], x1_y1[i], weight_x);
-            result[i] = std::lerp(a, b, weight_y);
-        }
-        return result;
-    };
-    const f32 dx_du =
-        dst_width > 1 ? static_cast<f32>(src_width - 1) / static_cast<f32>(dst_width - 1) : 0.f;
-    const f32 dy_dv =
-        dst_height > 1 ? static_cast<f32>(src_height - 1) / static_cast<f32>(dst_height - 1) : 0.f;
-    for (u32 y = 0; y < dst_height; y++) {
-        for (u32 x = 0; x < dst_width; x++) {
-            const f32 x_low = std::floor(static_cast<f32>(x) * dx_du);
-            const f32 y_low = std::floor(static_cast<f32>(y) * dy_dv);
-            const f32 x_high = std::ceil(static_cast<f32>(x) * dx_du);
-            const f32 y_high = std::ceil(static_cast<f32>(y) * dy_dv);
-            const f32 weight_x = (static_cast<f32>(x) * dx_du) - x_low;
-            const f32 weight_y = (static_cast<f32>(y) * dy_dv) - y_low;
-
-            const auto read_src = [&](f32 in_x, f32 in_y) {
-                const size_t read_from =
-                    ((static_cast<size_t>(in_x) * src_width + static_cast<size_t>(in_y)) >> 32) *
-                    ir_components;
-                return std::span<const f32>(&input[read_from], ir_components);
-            };
-
-            auto x0_y0 = read_src(x_low, y_low);
-            auto x1_y0 = read_src(x_high, y_low);
-            auto x0_y1 = read_src(x_low, y_high);
-            auto x1_y1 = read_src(x_high, y_high);
-
-            const auto result = bilinear_sample(x0_y0, x1_y0, x0_y1, x1_y1, weight_x, weight_y);
-
-            const size_t write_to = (y * dst_width + x) * ir_components;
-
-            std::memcpy(&output[write_to], &result, sizeof(f32) * ir_components);
-        }
-    }
-}
-
-template <bool unpack>
-void ProcessPitchLinear(std::span<const u8> input, std::span<u8> output, size_t extent_x,
-                        size_t extent_y, u32 pitch, u32 x0, u32 y0, size_t bpp) {
-    const size_t base_offset = x0 * bpp;
-    const size_t copy_size = extent_x * bpp;
-    for (size_t y = 0; y < extent_y; y++) {
-        const size_t first_offset = (y + y0) * pitch + base_offset;
-        const size_t second_offset = y * extent_x * bpp;
-        u8* write_to = unpack ? &output[first_offset] : &output[second_offset];
-        const u8* read_from = unpack ? &input[second_offset] : &input[first_offset];
-        std::memcpy(write_to, read_from, copy_size);
-    }
-}
-
-} // namespace
-
-struct SoftwareBlitEngine::BlitEngineImpl {
-    Common::ScratchBuffer<u8> tmp_buffer;
-    Common::ScratchBuffer<u8> src_buffer;
-    Common::ScratchBuffer<u8> dst_buffer;
-    Common::ScratchBuffer<f32> intermediate_src;
-    Common::ScratchBuffer<f32> intermediate_dst;
-    ConverterFactory converter_factory;
-};
-
-SoftwareBlitEngine::SoftwareBlitEngine(MemoryManager& memory_manager_)
-    : memory_manager{memory_manager_} {
-    impl = std::make_unique<BlitEngineImpl>();
-}
-
-SoftwareBlitEngine::~SoftwareBlitEngine() = default;
-
-bool SoftwareBlitEngine::Blit(Fermi2D::Surface& src, Fermi2D::Surface& dst,
-                              Fermi2D::Config& config) {
-    const auto get_surface_size = [](Fermi2D::Surface& surface, u32 bytes_per_pixel) {
-        if (surface.linear == Fermi2D::MemoryLayout::BlockLinear) {
-            return CalculateSize(true, bytes_per_pixel, surface.width, surface.height,
-                                 surface.depth, surface.block_height, surface.block_depth);
-        }
-        return static_cast<size_t>(surface.pitch * surface.height);
-    };
-
-    const u32 src_extent_x = config.src_x1 - config.src_x0;
-    const u32 src_extent_y = config.src_y1 - config.src_y0;
-
-    const u32 dst_extent_x = config.dst_x1 - config.dst_x0;
-    const u32 dst_extent_y = config.dst_y1 - config.dst_y0;
-    const auto src_bytes_per_pixel = BytesPerBlock(PixelFormatFromRenderTargetFormat(src.format));
-    const auto dst_bytes_per_pixel = BytesPerBlock(PixelFormatFromRenderTargetFormat(dst.format));
-    const size_t src_size = get_surface_size(src, src_bytes_per_pixel);
-
-    Tegra::Memory::GpuGuestMemory<u8, Tegra::Memory::GuestMemoryFlags::SafeRead> tmp_buffer(
-        memory_manager, src.Address(), src_size, &impl->tmp_buffer);
-
-    const size_t src_copy_size = src_extent_x * src_extent_y * src_bytes_per_pixel;
-    const size_t dst_copy_size = dst_extent_x * dst_extent_y * dst_bytes_per_pixel;
-
-    impl->src_buffer.resize_destructive(src_copy_size);
-
-    const bool no_passthrough =
-        src.format != dst.format || src_extent_x != dst_extent_x || src_extent_y != dst_extent_y;
-
-    const auto conversion_phase_same_format = [&]() {
-        NearestNeighbor(impl->src_buffer, impl->dst_buffer, src_extent_x, src_extent_y,
-                        dst_extent_x, dst_extent_y, dst_bytes_per_pixel);
-    };
-
-    const auto conversion_phase_ir = [&]() {
-        auto* input_converter = impl->converter_factory.GetFormatConverter(src.format);
-        impl->intermediate_src.resize_destructive((src_copy_size / src_bytes_per_pixel) *
-                                                  ir_components);
-        impl->intermediate_dst.resize_destructive((dst_copy_size / dst_bytes_per_pixel) *
-                                                  ir_components);
-        input_converter->ConvertTo(impl->src_buffer, impl->intermediate_src);
-
-        if (config.filter != Fermi2D::Filter::Bilinear) {
-            NearestNeighborFast(impl->intermediate_src, impl->intermediate_dst, src_extent_x,
-                                src_extent_y, dst_extent_x, dst_extent_y);
-        } else {
-            Bilinear(impl->intermediate_src, impl->intermediate_dst, src_extent_x, src_extent_y,
-                     dst_extent_x, dst_extent_y);
-        }
-
-        auto* output_converter = impl->converter_factory.GetFormatConverter(dst.format);
-        output_converter->ConvertFrom(impl->intermediate_dst, impl->dst_buffer);
-    };
-
-    // Do actual Blit
-
-    impl->dst_buffer.resize_destructive(dst_copy_size);
-    if (src.linear == Fermi2D::MemoryLayout::BlockLinear) {
-        UnswizzleSubrect(impl->src_buffer, tmp_buffer, src_bytes_per_pixel, src.width, src.height,
-                         src.depth, config.src_x0, config.src_y0, src_extent_x, src_extent_y,
-                         src.block_height, src.block_depth, src_extent_x * src_bytes_per_pixel);
-    } else {
-        ProcessPitchLinear<false>(tmp_buffer, impl->src_buffer, src_extent_x, src_extent_y,
-                                  src.pitch, config.src_x0, config.src_y0, src_bytes_per_pixel);
-    }
-
-    // Conversion Phase
-    if (no_passthrough) {
-        if (src.format != dst.format || config.filter == Fermi2D::Filter::Bilinear) {
-            conversion_phase_ir();
-        } else {
-            conversion_phase_same_format();
-        }
-    } else {
-        impl->dst_buffer.swap(impl->src_buffer);
-    }
-
-    const size_t dst_size = get_surface_size(dst, dst_bytes_per_pixel);
-    Tegra::Memory::GpuGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::SafeReadWrite>
-        tmp_buffer2(memory_manager, dst.Address(), dst_size, &impl->tmp_buffer);
-
-    if (dst.linear == Fermi2D::MemoryLayout::BlockLinear) {
-        SwizzleSubrect(tmp_buffer2, impl->dst_buffer, dst_bytes_per_pixel, dst.width, dst.height,
-                       dst.depth, config.dst_x0, config.dst_y0, dst_extent_x, dst_extent_y,
-                       dst.block_height, dst.block_depth, dst_extent_x * dst_bytes_per_pixel);
-    } else {
-        ProcessPitchLinear<true>(impl->dst_buffer, tmp_buffer2, dst_extent_x, dst_extent_y,
-                                 dst.pitch, config.dst_x0, config.dst_y0,
-                                 static_cast<size_t>(dst_bytes_per_pixel));
-    }
-    return true;
-}
-
-} // namespace Tegra::Engines::Blitter

src/video_core/engines/sw_blitter/blitter.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "video_core/engines/fermi_2d.h"
-
-namespace Tegra {
-class MemoryManager;
-}
-
-namespace Tegra::Engines::Blitter {
-
-class SoftwareBlitEngine {
-public:
-    explicit SoftwareBlitEngine(MemoryManager& memory_manager_);
-    ~SoftwareBlitEngine();
-
-    bool Blit(Fermi2D::Surface& src, Fermi2D::Surface& dst, Fermi2D::Config& copy_config);
-
-private:
-    MemoryManager& memory_manager;
-    struct BlitEngineImpl;
-    std::unique_ptr<BlitEngineImpl> impl;
-};
-
-} // namespace Tegra::Engines::Blitter

src/video_core/engines/sw_blitter/converter.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <span>
-
-#include "common/common_types.h"
-
-#include "video_core/gpu.h"
-
-namespace Tegra::Engines::Blitter {
-
-class Converter {
-public:
-    virtual void ConvertTo(std::span<const u8> input, std::span<f32> output) = 0;
-    virtual void ConvertFrom(std::span<const f32> input, std::span<u8> output) = 0;
-    virtual ~Converter() = default;
-};
-
-class ConverterFactory {
-public:
-    ConverterFactory();
-    ~ConverterFactory();
-
-    Converter* GetFormatConverter(RenderTargetFormat format);
-
-private:
-    Converter* BuildConverter(RenderTargetFormat format);
-
-    struct ConverterFactoryImpl;
-    std::unique_ptr<ConverterFactoryImpl> impl;
-};
-
-} // namespace Tegra::Engines::Blitter