cmake: make Vulkan-Headers external the default

texture_cache: Use pre-allocated heap buffer for texture swizzles

CMakeLists.txt

@@ -22,6 +22,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
 
+option(ENABLE_LIBUSB "Enable the use of LibUSB" ON)
+
 option(ENABLE_OPENGL "Enable OpenGL" ON)
 mark_as_advanced(FORCE ENABLE_OPENGL)
 option(ENABLE_QT "Enable the Qt frontend" ON)
@@ -35,6 +37,8 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
 
+option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
+
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -47,6 +51,8 @@ option(YUZU_TESTS "Compile tests" ON)
 
 option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
 
+option(YUZU_ROOM "Compile LDN room server" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)
 
 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
@@ -204,33 +210,39 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 find_package(enet 1.3)
 find_package(fmt 9 REQUIRED)
 find_package(inih)
-find_package(libusb 1.0.24)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3)
-find_package(Vulkan 1.3.238)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
+if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
+    find_package(Vulkan 1.3.238)
+endif()
+
+if (ENABLE_LIBUSB)
+    find_package(libusb 1.0.24)
+endif()
+
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    find_package(xbyak 6)
+    find_package(xbyak 6 QUIET)
 endif()
 
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    find_package(dynarmic 6.4.0)
+    find_package(dynarmic 6.4.0 QUIET)
 endif()
 
 if (ENABLE_CUBEB)
-    find_package(cubeb)
+    find_package(cubeb QUIET)
 endif()
 
 if (USE_DISCORD_PRESENCE)
-    find_package(DiscordRPC)
+    find_package(DiscordRPC QUIET)
 endif()
 
 if (ENABLE_WEB_SERVICE)
-    find_package(cpp-jwt 1.4)
-    find_package(httplib 0.11)
+    find_package(cpp-jwt 1.4 QUIET)
+    find_package(httplib 0.11 QUIET)
 endif()
 
 if (YUZU_TESTS)

externals/CMakeLists.txt

@@ -45,7 +45,7 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER
 endif()
 
 # libusb
-if (NOT TARGET libusb::usb)
+if (ENABLE_LIBUSB AND NOT TARGET libusb::usb)
     add_subdirectory(libusb EXCLUDE_FROM_ALL)
 endif()
 
@@ -152,6 +152,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 endif()
 
 # Vulkan-Headers
-if (NOT TARGET Vulkan::Headers)
+if (YUZU_USE_EXTERNAL_VULKAN_HEADERS)
     add_subdirectory(Vulkan-Headers EXCLUDE_FROM_ALL)
 endif()

src/CMakeLists.txt

@@ -161,7 +161,10 @@ add_subdirectory(video_core)
 add_subdirectory(network)
 add_subdirectory(input_common)
 add_subdirectory(shader_recompiler)
-add_subdirectory(dedicated_room)
+
+if (YUZU_ROOM)
+     add_subdirectory(dedicated_room)
+endif()
 
 if (YUZU_TESTS)
     add_subdirectory(tests)

src/audio_core/CMakeLists.txt

@@ -187,11 +187,7 @@ add_library(audio_core STATIC
     renderer/voice/voice_info.cpp
     renderer/voice/voice_info.h
     renderer/voice/voice_state.h
-    sink/cubeb_sink.cpp
-    sink/cubeb_sink.h
     sink/null_sink.h
-    sink/sdl2_sink.cpp
-    sink/sdl2_sink.h
     sink/sink.h
     sink/sink_details.cpp
     sink/sink_details.h
@@ -222,11 +218,22 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
     target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()
 
-if(ENABLE_CUBEB)
+if (ENABLE_CUBEB)
+    target_sources(audio_core PRIVATE
+        sink/cubeb_sink.cpp
+        sink/cubeb_sink.h
+    )
+
     target_link_libraries(audio_core PRIVATE cubeb::cubeb)
     target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
+
+if (ENABLE_SDL2)
+    target_sources(audio_core PRIVATE
+        sink/sdl2_sink.cpp
+        sink/sdl2_sink.h
+    )
+
     target_link_libraries(audio_core PRIVATE SDL2::SDL2)
     target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()

src/common/CMakeLists.txt

@@ -78,6 +78,7 @@ add_library(common STATIC
     logging/types.h
     lz4_compression.cpp
     lz4_compression.h
+    make_unique_for_overwrite.h
     math_util.h
     memory_detect.cpp
     memory_detect.h
@@ -101,6 +102,7 @@ add_library(common STATIC
     ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp
     scm_rev.h
     scope_exit.h
+    scratch_buffer.h
     settings.cpp
     settings.h
     settings_input.cpp

src/common/make_unique_for_overwrite.h

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+requires(!std::is_array_v<T>) std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+requires std::is_unbounded_array_v<T> std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common

src/common/scratch_buffer.h

@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/make_unique_for_overwrite.h"
+
+namespace Common {
+
+/**
+ * ScratchBuffer class
+ * This class creates a default initialized heap allocated buffer for cases such as intermediate
+ * buffers being copied into entirely, where value initializing members during allocation or resize
+ * is redundant.
+ */
+template <typename T>
+class ScratchBuffer {
+public:
+    ScratchBuffer() = default;
+
+    explicit ScratchBuffer(size_t initial_capacity)
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+
+    ~ScratchBuffer() = default;
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will remain intact.
+    void resize(size_t size) {
+        if (size > buffer_capacity) {
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
+            std::move(buffer.get(), buffer.get() + buffer_capacity, new_buffer.get());
+            buffer = std::move(new_buffer);
+            buffer_capacity = size;
+        }
+        last_requested_size = size;
+    }
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will be destroyed if a reallocation occurs.
+    void resize_destructive(size_t size) {
+        if (size > buffer_capacity) {
+            buffer_capacity = size;
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
+        }
+        last_requested_size = size;
+    }
+
+    [[nodiscard]] T* data() noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] const T* data() const noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] T* begin() noexcept {
+        return data();
+    }
+
+    [[nodiscard]] const T* begin() const noexcept {
+        return data();
+    }
+
+    [[nodiscard]] T* end() noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] const T* end() const noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] T& operator[](size_t i) {
+        return buffer[i];
+    }
+
+    [[nodiscard]] const T& operator[](size_t i) const {
+        return buffer[i];
+    }
+
+    [[nodiscard]] size_t size() const noexcept {
+        return last_requested_size;
+    }
+
+    [[nodiscard]] size_t capacity() const noexcept {
+        return buffer_capacity;
+    }
+
+private:
+    size_t last_requested_size{};
+    size_t buffer_capacity{};
+    std::unique_ptr<T[]> buffer{};
+};
+
+} // namespace Common

src/core/hid/emulated_controller.cpp

@@ -210,6 +210,13 @@ void EmulatedController::LoadTASParams() {
     tas_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
     tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
     tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
+
+    // set to optimal stick to avoid sanitizing the stick and tweaking the coordinates
+    // making sure they play back in the game as originally written down in the script file
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("range", 1.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("range", 1.0f);
 }
 
 void EmulatedController::LoadVirtualGamepadParams() {

src/core/hle/kernel/k_shared_memory.cpp

@@ -6,6 +6,7 @@
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -18,19 +19,19 @@ KSharedMemory::~KSharedMemory() {
 }
 
 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                                 Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                                 std::size_t size_, std::string name_) {
+                                 Svc::MemoryPermission owner_permission_,
+                                 Svc::MemoryPermission user_permission_, std::size_t size_,
+                                 std::string name_) {
     // Set members.
     owner_process = owner_process_;
     device_memory = &device_memory_;
-    page_list = std::move(page_list_);
     owner_permission = owner_permission_;
     user_permission = user_permission_;
-    physical_address = physical_address_;
-    size = size_;
+    size = Common::AlignUp(size_, PageSize);
     name = std::move(name_);
 
+    const size_t num_pages = Common::DivideUp(size, PageSize);
+
     // Get the resource limit.
     KResourceLimit* reslimit = kernel.GetSystemResourceLimit();
 
@@ -39,6 +40,17 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
                                                   size_);
     R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
+    // Allocate the memory.
+
+    //! HACK: Open continuous mapping from sysmodule pool.
+    auto option = KMemoryManager::EncodeOption(KMemoryManager::Pool::Secure,
+                                               KMemoryManager::Direction::FromBack);
+    physical_address = kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);
+    R_UNLESS(physical_address != 0, ResultOutOfMemory);
+
+    //! Insert the result into our page group.
+    page_group.emplace(physical_address, num_pages);
+
     // Commit our reservation.
     memory_reservation.Commit();
 
@@ -50,12 +62,23 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
     is_initialized = true;
 
     // Clear all pages in the memory.
-    std::memset(device_memory_.GetPointer<void>(physical_address_), 0, size_);
+    for (const auto& block : page_group->Nodes()) {
+        std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());
+    }
 
     return ResultSuccess;
 }
 
 void KSharedMemory::Finalize() {
+    // Close and finalize the page group.
+    // page_group->Close();
+    // page_group->Finalize();
+
+    //! HACK: Manually close.
+    for (const auto& block : page_group->Nodes()) {
+        kernel.MemoryManager().Close(block.GetAddress(), block.GetNumPages());
+    }
+
     // Release the memory reservation.
     resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);
     resource_limit->Close();
@@ -65,32 +88,28 @@ void KSharedMemory::Finalize() {
 }
 
 Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,
-                          Svc::MemoryPermission permissions) {
-    const u64 page_count{(map_size + PageSize - 1) / PageSize};
+                          Svc::MemoryPermission map_perm) {
+    // Validate the size.
+    R_UNLESS(size == map_size, ResultInvalidSize);
 
-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    const Svc::MemoryPermission expected =
+    // Validate the permission.
+    const Svc::MemoryPermission test_perm =
         &target_process == owner_process ? owner_permission : user_permission;
-
-    if (permissions != expected) {
-        UNIMPLEMENTED_MSG("Permission does not match");
+    if (test_perm == Svc::MemoryPermission::DontCare) {
+        ASSERT(map_perm == Svc::MemoryPermission::Read || map_perm == Svc::MemoryPermission::Write);
+    } else {
+        R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
     }
 
-    return target_process.PageTable().MapPages(address, page_list, KMemoryState::Shared,
-                                               ConvertToKMemoryPermission(permissions));
+    return target_process.PageTable().MapPages(address, *page_group, KMemoryState::Shared,
+                                               ConvertToKMemoryPermission(map_perm));
 }
 
 Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
-    const u64 page_count{(unmap_size + PageSize - 1) / PageSize};
+    // Validate the size.
+    R_UNLESS(size == unmap_size, ResultInvalidSize);
 
-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    return target_process.PageTable().UnmapPages(address, page_list, KMemoryState::Shared);
+    return target_process.PageTable().UnmapPages(address, *page_group, KMemoryState::Shared);
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_shared_memory.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <optional>
 #include <string>
 
 #include "common/common_types.h"
@@ -26,9 +27,8 @@ public:
     ~KSharedMemory() override;
 
     Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                      Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                      std::size_t size_, std::string name_);
+                      Svc::MemoryPermission owner_permission_,
+                      Svc::MemoryPermission user_permission_, std::size_t size_, std::string name_);
 
     /**
      * Maps a shared memory block to an address in the target process' address space
@@ -76,7 +76,7 @@ public:
 private:
     Core::DeviceMemory* device_memory{};
     KProcess* owner_process{};
-    KPageGroup page_list;
+    std::optional<KPageGroup> page_group{};
     Svc::MemoryPermission owner_permission{};
     Svc::MemoryPermission user_permission{};
     PAddr physical_address{};

src/core/hle/kernel/kernel.cpp

@@ -94,6 +94,7 @@ struct KernelCore::Impl {
                                        pt_heap_region.GetSize());
         }
 
+        InitializeHackSharedMemory();
         RegisterHostThread(nullptr);
 
         default_service_thread = &CreateServiceThread(kernel, "DefaultServiceThread");
@@ -726,14 +727,14 @@ struct KernelCore::Impl {
     }
 
     void InitializeMemoryLayout() {
-        const auto system_pool = memory_layout->GetKernelSystemPoolRegionPhysicalExtents();
-
         // Initialize the memory manager.
         memory_manager = std::make_unique<KMemoryManager>(system);
         const auto& management_region = memory_layout->GetPoolManagementRegion();
         ASSERT(management_region.GetEndAddress() != 0);
         memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());
+    }
 
+    void InitializeHackSharedMemory() {
         // Setup memory regions for emulated processes
         // TODO(bunnei): These should not be hardcoded regions initialized within the kernel
         constexpr std::size_t hid_size{0x40000};
@@ -742,39 +743,23 @@ struct KernelCore::Impl {
         constexpr std::size_t time_size{0x1000};
         constexpr std::size_t hidbus_size{0x1000};
 
-        const PAddr hid_phys_addr{system_pool.GetAddress()};
-        const PAddr font_phys_addr{system_pool.GetAddress() + hid_size};
-        const PAddr irs_phys_addr{system_pool.GetAddress() + hid_size + font_size};
-        const PAddr time_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size};
-        const PAddr hidbus_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size +
-                                     time_size};
-
         hid_shared_mem = KSharedMemory::Create(system.Kernel());
         font_shared_mem = KSharedMemory::Create(system.Kernel());
         irs_shared_mem = KSharedMemory::Create(system.Kernel());
         time_shared_mem = KSharedMemory::Create(system.Kernel());
         hidbus_shared_mem = KSharedMemory::Create(system.Kernel());
 
-        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                   {hid_phys_addr, hid_size / PageSize},
-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                   hid_phys_addr, hid_size, "HID:SharedMemory");
-        font_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                    {font_phys_addr, font_size / PageSize},
-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                    font_phys_addr, font_size, "Font:SharedMemory");
-        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                   {irs_phys_addr, irs_size / PageSize},
-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                   irs_phys_addr, irs_size, "IRS:SharedMemory");
-        time_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                    {time_phys_addr, time_size / PageSize},
-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                    time_phys_addr, time_size, "Time:SharedMemory");
-        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                      {hidbus_phys_addr, hidbus_size / PageSize},
-                                      Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                      hidbus_phys_addr, hidbus_size, "HidBus:SharedMemory");
+        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                   Svc::MemoryPermission::Read, hid_size, "HID:SharedMemory");
+        font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                    Svc::MemoryPermission::Read, font_size, "Font:SharedMemory");
+        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                   Svc::MemoryPermission::Read, irs_size, "IRS:SharedMemory");
+        time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                    Svc::MemoryPermission::Read, time_size, "Time:SharedMemory");
+        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                      Svc::MemoryPermission::Read, hidbus_size,
+                                      "HidBus:SharedMemory");
     }
 
     KClientPort* CreateNamedServicePort(std::string name) {

src/core/hle/service/time/clock_types.h

@@ -49,6 +49,7 @@ struct SteadyClockContext {
 static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
 static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
               "SteadyClockContext must be trivially copyable");
+using StandardSteadyClockTimePointType = SteadyClockContext;
 
 struct SystemClockContext {
     s64 offset;

src/core/hle/service/time/time_sharedmemory.cpp

@@ -26,23 +26,24 @@ void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
     const Clock::SteadyClockContext context{
         static_cast<u64>(current_time_point.nanoseconds - ticks_time_span.nanoseconds),
         clock_source_id};
-    shared_memory_format.standard_steady_clock_timepoint.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_steady_clock_timepoint, context);
 }
 
 void SharedMemory::UpdateLocalSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_local_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_local_system_clock_context, context);
 }
 
 void SharedMemory::UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_network_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+    StoreToLockFreeAtomicType(&GetFormat()->standard_network_system_clock_context, context);
 }
 
 void SharedMemory::SetAutomaticCorrectionEnabled(bool is_enabled) {
-    shared_memory_format.standard_user_system_clock_automatic_correction.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), is_enabled);
+    StoreToLockFreeAtomicType(
+        &GetFormat()->is_standard_user_system_clock_automatic_correction_enabled, is_enabled);
+}
+
+SharedMemory::Format* SharedMemory::GetFormat() {
+    return reinterpret_cast<SharedMemory::Format*>(system.Kernel().GetTimeSharedMem().GetPointer());
 }
 
 } // namespace Service::Time

src/core/hle/service/time/time_sharedmemory.h

@@ -10,45 +10,68 @@
 
 namespace Service::Time {
 
+// Note: this type is not safe for concurrent writes.
+template <typename T>
+struct LockFreeAtomicType {
+    u32 counter_;
+    std::array<T, 2> value_;
+};
+
+template <typename T>
+static inline void StoreToLockFreeAtomicType(LockFreeAtomicType<T>* p, const T& value) {
+    // Get the current counter.
+    auto counter = p->counter_;
+
+    // Increment the counter.
+    ++counter;
+
+    // Store the updated value.
+    p->value_[counter % 2] = value;
+
+    // Fence memory.
+    std::atomic_thread_fence(std::memory_order_release);
+
+    // Set the updated counter.
+    p->counter_ = counter;
+}
+
+template <typename T>
+static inline T LoadFromLockFreeAtomicType(const LockFreeAtomicType<T>* p) {
+    while (true) {
+        // Get the counter.
+        auto counter = p->counter_;
+
+        // Get the value.
+        auto value = p->value_[counter % 2];
+
+        // Fence memory.
+        std::atomic_thread_fence(std::memory_order_acquire);
+
+        // Check that the counter matches.
+        if (counter == p->counter_) {
+            return value;
+        }
+    }
+}
+
 class SharedMemory final {
 public:
     explicit SharedMemory(Core::System& system_);
     ~SharedMemory();
 
-    // TODO(ogniK): We have to properly simulate memory barriers, how are we going to do this?
-    template <typename T, std::size_t Offset>
-    struct MemoryBarrier {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-        u32_le read_attempt{};
-        std::array<T, 2> data{};
-
-        // These are not actually memory barriers at the moment as we don't have multicore and all
-        // HLE is mutexed. This will need to properly be implemented when we start updating the time
-        // points on threads. As of right now, we'll be updated both values synchronously and just
-        // incrementing the read_attempt to indicate that we waited.
-        void StoreData(u8* shared_memory, T data_to_store) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            read_attempt++;
-            data[read_attempt & 1] = data_to_store;
-            std::memcpy(shared_memory + Offset, this, sizeof(*this));
-        }
-
-        // For reading we're just going to read the last stored value. If there was no value stored
-        // it will just end up reading an empty value as intended.
-        T ReadData(u8* shared_memory) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            return data[(read_attempt - 1) & 1];
-        }
-    };
-
     // Shared memory format
     struct Format {
-        MemoryBarrier<Clock::SteadyClockContext, 0x0> standard_steady_clock_timepoint;
-        MemoryBarrier<Clock::SystemClockContext, 0x38> standard_local_system_clock_context;
-        MemoryBarrier<Clock::SystemClockContext, 0x80> standard_network_system_clock_context;
-        MemoryBarrier<bool, 0xc8> standard_user_system_clock_automatic_correction;
-        u32_le format_version;
+        LockFreeAtomicType<Clock::StandardSteadyClockTimePointType> standard_steady_clock_timepoint;
+        LockFreeAtomicType<Clock::SystemClockContext> standard_local_system_clock_context;
+        LockFreeAtomicType<Clock::SystemClockContext> standard_network_system_clock_context;
+        LockFreeAtomicType<bool> is_standard_user_system_clock_automatic_correction_enabled;
+        u32 format_version;
     };
+    static_assert(offsetof(Format, standard_steady_clock_timepoint) == 0x0);
+    static_assert(offsetof(Format, standard_local_system_clock_context) == 0x38);
+    static_assert(offsetof(Format, standard_network_system_clock_context) == 0x80);
+    static_assert(offsetof(Format, is_standard_user_system_clock_automatic_correction_enabled) ==
+                  0xc8);
     static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
 
     void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
@@ -56,10 +79,10 @@ public:
     void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
     void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
     void SetAutomaticCorrectionEnabled(bool is_enabled);
+    Format* GetFormat();
 
 private:
     Core::System& system;
-    Format shared_memory_format{};
 };
 
 } // namespace Service::Time

src/input_common/CMakeLists.txt

@@ -4,14 +4,10 @@
 add_library(input_common STATIC
     drivers/camera.cpp
     drivers/camera.h
-    drivers/gc_adapter.cpp
-    drivers/gc_adapter.h
     drivers/keyboard.cpp
     drivers/keyboard.h
     drivers/mouse.cpp
     drivers/mouse.h
-    drivers/sdl_driver.cpp
-    drivers/sdl_driver.h
     drivers/tas_input.cpp
     drivers/tas_input.h
     drivers/touch_screen.cpp
@@ -62,8 +58,17 @@ if (ENABLE_SDL2)
     target_compile_definitions(input_common PRIVATE HAVE_SDL2)
 endif()
 
+if (ENABLE_LIBUSB)
+    target_sources(input_common PRIVATE
+        drivers/gc_adapter.cpp
+        drivers/gc_adapter.h
+    )
+    target_link_libraries(input_common PRIVATE libusb::usb)
+    target_compile_definitions(input_common PRIVATE HAVE_LIBUSB)
+endif()
+
 create_target_directory_groups(input_common)
-target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost libusb::usb)
+target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost)
 
 if (YUZU_USE_PRECOMPILED_HEADERS)
     target_precompile_headers(input_common PRIVATE precompiled_headers.h)

src/input_common/main.cpp

@@ -5,7 +5,6 @@
 #include "common/input.h"
 #include "common/param_package.h"
 #include "input_common/drivers/camera.h"
-#include "input_common/drivers/gc_adapter.h"
 #include "input_common/drivers/keyboard.h"
 #include "input_common/drivers/mouse.h"
 #include "input_common/drivers/tas_input.h"
@@ -19,6 +18,10 @@
 #include "input_common/input_mapping.h"
 #include "input_common/input_poller.h"
 #include "input_common/main.h"
+
+#ifdef HAVE_LIBUSB
+#include "input_common/drivers/gc_adapter.h"
+#endif
 #ifdef HAVE_SDL2
 #include "input_common/drivers/sdl_driver.h"
 #endif
@@ -45,7 +48,9 @@ struct InputSubsystem::Impl {
         RegisterEngine("keyboard", keyboard);
         RegisterEngine("mouse", mouse);
         RegisterEngine("touch", touch_screen);
+#ifdef HAVE_LIBUSB
         RegisterEngine("gcpad", gcadapter);
+#endif
         RegisterEngine("cemuhookudp", udp_client);
         RegisterEngine("tas", tas_input);
         RegisterEngine("camera", camera);
@@ -72,7 +77,9 @@ struct InputSubsystem::Impl {
         UnregisterEngine(keyboard);
         UnregisterEngine(mouse);
         UnregisterEngine(touch_screen);
+#ifdef HAVE_LIBUSB
         UnregisterEngine(gcadapter);
+#endif
         UnregisterEngine(udp_client);
         UnregisterEngine(tas_input);
         UnregisterEngine(camera);
@@ -95,8 +102,10 @@ struct InputSubsystem::Impl {
         devices.insert(devices.end(), keyboard_devices.begin(), keyboard_devices.end());
         auto mouse_devices = mouse->GetInputDevices();
         devices.insert(devices.end(), mouse_devices.begin(), mouse_devices.end());
+#ifdef HAVE_LIBUSB
         auto gcadapter_devices = gcadapter->GetInputDevices();
         devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
+#endif
         auto udp_devices = udp_client->GetInputDevices();
         devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
 #ifdef HAVE_SDL2
@@ -119,9 +128,11 @@ struct InputSubsystem::Impl {
         if (engine == mouse->GetEngineName()) {
             return mouse;
         }
+#ifdef HAVE_LIBUSB
         if (engine == gcadapter->GetEngineName()) {
             return gcadapter;
         }
+#endif
         if (engine == udp_client->GetEngineName()) {
             return udp_client;
         }
@@ -194,9 +205,11 @@ struct InputSubsystem::Impl {
         if (engine == mouse->GetEngineName()) {
             return true;
         }
+#ifdef HAVE_LIBUSB
         if (engine == gcadapter->GetEngineName()) {
             return true;
         }
+#endif
         if (engine == udp_client->GetEngineName()) {
             return true;
         }
@@ -217,7 +230,9 @@ struct InputSubsystem::Impl {
     void BeginConfiguration() {
         keyboard->BeginConfiguration();
         mouse->BeginConfiguration();
+#ifdef HAVE_LIBUSB
         gcadapter->BeginConfiguration();
+#endif
         udp_client->BeginConfiguration();
 #ifdef HAVE_SDL2
         sdl->BeginConfiguration();
@@ -227,7 +242,9 @@ struct InputSubsystem::Impl {
     void EndConfiguration() {
         keyboard->EndConfiguration();
         mouse->EndConfiguration();
+#ifdef HAVE_LIBUSB
         gcadapter->EndConfiguration();
+#endif
         udp_client->EndConfiguration();
 #ifdef HAVE_SDL2
         sdl->EndConfiguration();
@@ -248,7 +265,6 @@ struct InputSubsystem::Impl {
 
     std::shared_ptr<Keyboard> keyboard;
     std::shared_ptr<Mouse> mouse;
-    std::shared_ptr<GCAdapter> gcadapter;
     std::shared_ptr<TouchScreen> touch_screen;
     std::shared_ptr<TasInput::Tas> tas_input;
     std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
@@ -256,6 +272,10 @@ struct InputSubsystem::Impl {
     std::shared_ptr<VirtualAmiibo> virtual_amiibo;
     std::shared_ptr<VirtualGamepad> virtual_gamepad;
 
+#ifdef HAVE_LIBUSB
+    std::shared_ptr<GCAdapter> gcadapter;
+#endif
+
 #ifdef HAVE_SDL2
     std::shared_ptr<SDLDriver> sdl;
 #endif

src/tests/CMakeLists.txt

@@ -8,6 +8,7 @@ add_executable(tests
     common/host_memory.cpp
     common/param_package.cpp
     common/ring_buffer.cpp
+    common/scratch_buffer.cpp
     common/unique_function.cpp
     core/core_timing.cpp
     core/internal_network/network.cpp

src/tests/common/scratch_buffer.cpp

@@ -0,0 +1,200 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <span>
+#include <catch2/catch.hpp>
+#include "common/common_types.h"
+#include "common/scratch_buffer.h"
+
+namespace Common {
+
+TEST_CASE("ScratchBuffer: Basic Test", "[common]") {
+    ScratchBuffer<u8> buf;
+
+    REQUIRE(buf.size() == 0U);
+    REQUIRE(buf.capacity() == 0U);
+
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    buf.resize(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: resize_destructive Grow", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    // Increasing the size should reallocate the buffer
+    buf.resize_destructive(payload.size() * 2);
+    REQUIRE(buf.size() == payload.size() * 2);
+    REQUIRE(buf.capacity() == payload.size() * 2);
+
+    // Since the buffer is not value initialized, reading its data will be garbage
+}
+
+TEST_CASE("ScratchBuffer: resize_destructive Shrink", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    // Decreasing the size should not cause a buffer reallocation
+    // This can be tested by ensuring the buffer capacity and data has not changed,
+    buf.resize_destructive(1U);
+    REQUIRE(buf.size() == 1U);
+    REQUIRE(buf.capacity() == payload.size());
+
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: resize Grow u8", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    // Increasing the size should reallocate the buffer
+    buf.resize(payload.size() * 2);
+    REQUIRE(buf.size() == payload.size() * 2);
+    REQUIRE(buf.capacity() == payload.size() * 2);
+
+    // resize() keeps the previous data intact
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: resize Grow u64", "[common]") {
+    std::array<u64, 10> payload;
+    payload.fill(6666);
+
+    ScratchBuffer<u64> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size() * sizeof(u64));
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    // Increasing the size should reallocate the buffer
+    buf.resize(payload.size() * 2);
+    REQUIRE(buf.size() == payload.size() * 2);
+    REQUIRE(buf.capacity() == payload.size() * 2);
+
+    // resize() keeps the previous data intact
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: resize Shrink", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    // Decreasing the size should not cause a buffer reallocation
+    // This can be tested by ensuring the buffer capacity and data has not changed,
+    buf.resize(1U);
+    REQUIRE(buf.size() == 1U);
+    REQUIRE(buf.capacity() == payload.size());
+
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: Span Size", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    buf.resize(3U);
+    REQUIRE(buf.size() == 3U);
+    REQUIRE(buf.capacity() == payload.size());
+
+    const auto buf_span = std::span<u8>(buf);
+    // The span size is the last requested size of the buffer, not its capacity
+    REQUIRE(buf_span.size() == buf.size());
+
+    for (size_t i = 0; i < buf_span.size(); ++i) {
+        REQUIRE(buf_span[i] == buf[i]);
+        REQUIRE(buf_span[i] == payload[i]);
+    }
+}
+
+TEST_CASE("ScratchBuffer: Span Writes", "[common]") {
+    std::array<u8, 10> payload;
+    payload.fill(66);
+
+    ScratchBuffer<u8> buf(payload.size());
+    REQUIRE(buf.size() == payload.size());
+    REQUIRE(buf.capacity() == payload.size());
+
+    std::memcpy(buf.data(), payload.data(), payload.size());
+    for (size_t i = 0; i < payload.size(); ++i) {
+        REQUIRE(buf[i] == payload[i]);
+    }
+
+    buf.resize(3U);
+    REQUIRE(buf.size() == 3U);
+    REQUIRE(buf.capacity() == payload.size());
+
+    const auto buf_span = std::span<u8>(buf);
+    REQUIRE(buf_span.size() == buf.size());
+
+    for (size_t i = 0; i < buf_span.size(); ++i) {
+        const auto new_value = static_cast<u8>(i + 1U);
+        // Writes to a span of the scratch buffer will propogate to the buffer itself
+        buf_span[i] = new_value;
+        REQUIRE(buf[i] == new_value);
+    }
+}
+
+} // namespace Common

src/video_core/buffer_cache/buffer_cache.h

@@ -20,6 +20,7 @@
 #include "common/lru_cache.h"
 #include "common/microprofile.h"
 #include "common/polyfill_ranges.h"
+#include "common/scratch_buffer.h"
 #include "common/settings.h"
 #include "core/memory.h"
 #include "video_core/buffer_cache/buffer_base.h"
@@ -422,8 +423,7 @@ private:
     IntervalSet common_ranges;
     std::deque<IntervalSet> committed_ranges;
 
-    size_t immediate_buffer_capacity = 0;
-    std::unique_ptr<u8[]> immediate_buffer_alloc;
+    Common::ScratchBuffer<u8> immediate_buffer_alloc;
 
     struct LRUItemParams {
         using ObjectType = BufferId;
@@ -1926,11 +1926,8 @@ std::span<const u8> BufferCache<P>::ImmediateBufferWithData(VAddr cpu_addr, size
 
 template <class P>
 std::span<u8> BufferCache<P>::ImmediateBuffer(size_t wanted_capacity) {
-    if (wanted_capacity > immediate_buffer_capacity) {
-        immediate_buffer_capacity = wanted_capacity;
-        immediate_buffer_alloc = std::make_unique<u8[]>(wanted_capacity);
-    }
-    return std::span<u8>(immediate_buffer_alloc.get(), wanted_capacity);
+    immediate_buffer_alloc.resize_destructive(wanted_capacity);
+    return std::span<u8>(immediate_buffer_alloc.data(), wanted_capacity);
 }
 
 template <class P>

src/video_core/dma_pusher.cpp

@@ -56,7 +56,7 @@ bool DmaPusher::Step() {
 
     if (command_list.prefetch_command_list.size()) {
         // Prefetched command list from nvdrv, used for things like synchronization
-        command_headers = std::move(command_list.prefetch_command_list);
+        ProcessCommands(command_list.prefetch_command_list);
         dma_pushbuffer.pop();
     } else {
         const CommandListHeader command_list_header{
@@ -74,7 +74,7 @@ bool DmaPusher::Step() {
         }
 
         // Push buffer non-empty, read a word
-        command_headers.resize(command_list_header.size);
+        command_headers.resize_destructive(command_list_header.size);
         if (Settings::IsGPULevelHigh()) {
             memory_manager.ReadBlock(dma_get, command_headers.data(),
                                      command_list_header.size * sizeof(u32));
@@ -82,16 +82,21 @@ bool DmaPusher::Step() {
             memory_manager.ReadBlockUnsafe(dma_get, command_headers.data(),
                                            command_list_header.size * sizeof(u32));
         }
+        ProcessCommands(command_headers);
     }
-    for (std::size_t index = 0; index < command_headers.size();) {
-        const CommandHeader& command_header = command_headers[index];
+
+    return true;
+}
+
+void DmaPusher::ProcessCommands(std::span<const CommandHeader> commands) {
+    for (std::size_t index = 0; index < commands.size();) {
+        const CommandHeader& command_header = commands[index];
 
         if (dma_state.method_count) {
             // Data word of methods command
             if (dma_state.non_incrementing) {
                 const u32 max_write = static_cast<u32>(
-                    std::min<std::size_t>(index + dma_state.method_count, command_headers.size()) -
-                    index);
+                    std::min<std::size_t>(index + dma_state.method_count, commands.size()) - index);
                 CallMultiMethod(&command_header.argument, max_write);
                 dma_state.method_count -= max_write;
                 dma_state.is_last_call = true;
@@ -142,8 +147,6 @@ bool DmaPusher::Step() {
         }
         index++;
     }
-
-    return true;
 }
 
 void DmaPusher::SetState(const CommandHeader& command_header) {

src/video_core/dma_pusher.h

@@ -4,11 +4,13 @@
 #pragma once
 
 #include <array>
+#include <span>
 #include <vector>
 #include <queue>
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "common/scratch_buffer.h"
 #include "video_core/engines/engine_interface.h"
 #include "video_core/engines/puller.h"
 
@@ -136,13 +138,15 @@ private:
     static constexpr u32 non_puller_methods = 0x40;
     static constexpr u32 max_subchannels = 8;
     bool Step();
+    void ProcessCommands(std::span<const CommandHeader> commands);
 
     void SetState(const CommandHeader& command_header);
 
     void CallMethod(u32 argument) const;
     void CallMultiMethod(const u32* base_start, u32 num_methods) const;
 
-    std::vector<CommandHeader> command_headers; ///< Buffer for list of commands fetched at once
+    Common::ScratchBuffer<CommandHeader>
+        command_headers; ///< Buffer for list of commands fetched at once
 
     std::queue<CommandList> dma_pushbuffer; ///< Queue of command lists to be processed
     std::size_t dma_pushbuffer_subindex{};  ///< Index within a command list within the pushbuffer
@@ -159,7 +163,7 @@ private:
     DmaState dma_state{};
     bool dma_increment_once{};
 
-    bool ib_enable{true}; ///< IB mode enabled
+    const bool ib_enable{true}; ///< IB mode enabled
 
     std::array<Engines::EngineInterface*, max_subchannels> subchannels{};
 

src/video_core/engines/engine_upload.cpp

@@ -24,7 +24,7 @@ void State::BindRasterizer(VideoCore::RasterizerInterface* rasterizer_) {
 void State::ProcessExec(const bool is_linear_) {
     write_offset = 0;
     copy_size = regs.line_length_in * regs.line_count;
-    inner_buffer.resize(copy_size);
+    inner_buffer.resize_destructive(copy_size);
     is_linear = is_linear_;
 }
 
@@ -70,7 +70,7 @@ void State::ProcessData(std::span<const u8> read_buffer) {
         const std::size_t dst_size = Tegra::Texture::CalculateSize(
             true, bytes_per_pixel, width, regs.dest.height, regs.dest.depth,
             regs.dest.BlockHeight(), regs.dest.BlockDepth());
-        tmp_buffer.resize(dst_size);
+        tmp_buffer.resize_destructive(dst_size);
         memory_manager.ReadBlock(address, tmp_buffer.data(), dst_size);
         Tegra::Texture::SwizzleSubrect(tmp_buffer, read_buffer, bytes_per_pixel, width,
                                        regs.dest.height, regs.dest.depth, x_offset, regs.dest.y,

src/video_core/engines/engine_upload.h

@@ -4,9 +4,10 @@
 #pragma once
 
 #include <span>
-#include <vector>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "common/scratch_buffer.h"
 
 namespace Tegra {
 class MemoryManager;
@@ -73,8 +74,8 @@ private:
 
     u32 write_offset = 0;
     u32 copy_size = 0;
-    std::vector<u8> inner_buffer;
-    std::vector<u8> tmp_buffer;
+    Common::ScratchBuffer<u8> inner_buffer;
+    Common::ScratchBuffer<u8> tmp_buffer;
     bool is_linear = false;
     Registers& regs;
     MemoryManager& memory_manager;

src/video_core/engines/maxwell_dma.cpp

@@ -184,12 +184,8 @@ void MaxwellDMA::CopyBlockLinearToPitch() {
     const size_t src_size =
         CalculateSize(true, bytes_per_pixel, width, height, depth, block_height, block_depth);
 
-    if (read_buffer.size() < src_size) {
-        read_buffer.resize(src_size);
-    }
-    if (write_buffer.size() < dst_size) {
-        write_buffer.resize(dst_size);
-    }
+    read_buffer.resize_destructive(src_size);
+    write_buffer.resize_destructive(dst_size);
 
     memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
     memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);
@@ -235,12 +231,8 @@ void MaxwellDMA::CopyPitchToBlockLinear() {
         CalculateSize(true, bytes_per_pixel, width, height, depth, block_height, block_depth);
     const size_t src_size = static_cast<size_t>(regs.pitch_in) * regs.line_count;
 
-    if (read_buffer.size() < src_size) {
-        read_buffer.resize(src_size);
-    }
-    if (write_buffer.size() < dst_size) {
-        write_buffer.resize(dst_size);
-    }
+    read_buffer.resize_destructive(src_size);
+    write_buffer.resize_destructive(dst_size);
 
     memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
     if (Settings::IsGPULevelExtreme()) {
@@ -269,12 +261,8 @@ void MaxwellDMA::FastCopyBlockLinearToPitch() {
     pos_x = pos_x % x_in_gob;
     pos_y = pos_y % 8;
 
-    if (read_buffer.size() < src_size) {
-        read_buffer.resize(src_size);
-    }
-    if (write_buffer.size() < dst_size) {
-        write_buffer.resize(dst_size);
-    }
+    read_buffer.resize_destructive(src_size);
+    write_buffer.resize_destructive(dst_size);
 
     if (Settings::IsGPULevelExtreme()) {
         memory_manager.ReadBlock(regs.offset_in + offset, read_buffer.data(), src_size);
@@ -333,14 +321,10 @@ void MaxwellDMA::CopyBlockLinearToBlockLinear() {
     const u32 pitch = x_elements * bytes_per_pixel;
     const size_t mid_buffer_size = pitch * regs.line_count;
 
-    if (read_buffer.size() < src_size) {
-        read_buffer.resize(src_size);
-    }
-    if (write_buffer.size() < dst_size) {
-        write_buffer.resize(dst_size);
-    }
+    read_buffer.resize_destructive(src_size);
+    write_buffer.resize_destructive(dst_size);
 
-    intermediate_buffer.resize(mid_buffer_size);
+    intermediate_buffer.resize_destructive(mid_buffer_size);
 
     memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
     memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);

src/video_core/engines/maxwell_dma.h

@@ -6,8 +6,10 @@
 #include <array>
 #include <cstddef>
 #include <vector>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "common/scratch_buffer.h"
 #include "video_core/engines/engine_interface.h"
 
 namespace Core {
@@ -234,9 +236,9 @@ private:
     MemoryManager& memory_manager;
     VideoCore::RasterizerInterface* rasterizer = nullptr;
 
-    std::vector<u8> read_buffer;
-    std::vector<u8> write_buffer;
-    std::vector<u8> intermediate_buffer;
+    Common::ScratchBuffer<u8> read_buffer;
+    Common::ScratchBuffer<u8> write_buffer;
+    Common::ScratchBuffer<u8> intermediate_buffer;
 
     static constexpr std::size_t NUM_REGS = 0x800;
     struct Regs {

src/video_core/host1x/vic.cpp

@@ -155,7 +155,7 @@ void Vic::WriteRGBFrame(const AVFrame* frame, const VicConfig& config) {
         // swizzle pitch linear to block linear
         const u32 block_height = static_cast<u32>(config.block_linear_height_log2);
         const auto size = Texture::CalculateSize(true, 4, width, height, 1, block_height, 0);
-        luma_buffer.resize(size);
+        luma_buffer.resize_destructive(size);
         std::span<const u8> frame_buff(converted_frame_buf_addr, 4 * width * height);
         Texture::SwizzleSubrect(luma_buffer, frame_buff, 4, width, height, 1, 0, 0, width, height,
                                 block_height, 0, width * 4);
@@ -181,8 +181,8 @@ void Vic::WriteYUVFrame(const AVFrame* frame, const VicConfig& config) {
 
     const auto stride = static_cast<size_t>(frame->linesize[0]);
 
-    luma_buffer.resize(aligned_width * surface_height);
-    chroma_buffer.resize(aligned_width * surface_height / 2);
+    luma_buffer.resize_destructive(aligned_width * surface_height);
+    chroma_buffer.resize_destructive(aligned_width * surface_height / 2);
 
     // Populate luma buffer
     const u8* luma_src = frame->data[0];

src/video_core/host1x/vic.h

@@ -4,8 +4,9 @@
 #pragma once
 
 #include <memory>
-#include <vector>
+
 #include "common/common_types.h"
+#include "common/scratch_buffer.h"
 
 struct SwsContext;
 
@@ -49,8 +50,8 @@ private:
     /// size does not change during a stream
     using AVMallocPtr = std::unique_ptr<u8, decltype(&av_free)>;
     AVMallocPtr converted_frame_buffer;
-    std::vector<u8> luma_buffer;
-    std::vector<u8> chroma_buffer;
+    Common::ScratchBuffer<u8> luma_buffer;
+    Common::ScratchBuffer<u8> chroma_buffer;
 
     GPUVAddr config_struct_address{};
     GPUVAddr output_surface_luma_address{};

src/video_core/texture_cache/texture_cache.h

@@ -39,6 +39,12 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
     sampler_descriptor.mipmap_filter.Assign(Tegra::Texture::TextureMipmapFilter::Linear);
     sampler_descriptor.cubemap_anisotropy.Assign(1);
 
+    // These values were chosen based on typical peak swizzle data sizes seen in some titles
+    static constexpr size_t SWIZZLE_DATA_BUFFER_INITIAL_CAPACITY = 8_MiB;
+    static constexpr size_t UNSWIZZLE_DATA_BUFFER_INITIAL_CAPACITY = 1_MiB;
+    swizzle_data_buffer.resize_destructive(SWIZZLE_DATA_BUFFER_INITIAL_CAPACITY);
+    unswizzle_data_buffer.resize_destructive(UNSWIZZLE_DATA_BUFFER_INITIAL_CAPACITY);
+
     // Make sure the first index is reserved for the null resources
     // This way the null resource becomes a compile time constant
     void(slot_images.insert(NullImageParams{}));
@@ -90,7 +96,8 @@ void TextureCache<P>::RunGarbageCollector() {
             const auto copies = FullDownloadCopies(image.info);
             image.DownloadMemory(map, copies);
             runtime.Finish();
-            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span);
+            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
+                         swizzle_data_buffer);
         }
         if (True(image.flags & ImageFlagBits::Tracked)) {
             UntrackImage(image, image_id);
@@ -461,7 +468,8 @@ void TextureCache<P>::DownloadMemory(VAddr cpu_addr, size_t size) {
         const auto copies = FullDownloadCopies(image.info);
         image.DownloadMemory(map, copies);
         runtime.Finish();
-        SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span);
+        SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
+                     swizzle_data_buffer);
     }
 }
 
@@ -672,7 +680,8 @@ void TextureCache<P>::PopAsyncFlushes() {
     for (const ImageId image_id : download_ids) {
         const ImageBase& image = slot_images[image_id];
         const auto copies = FullDownloadCopies(image.info);
-        SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, download_span);
+        SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, download_span,
+                     swizzle_data_buffer);
         download_map.offset += image.unswizzled_size_bytes;
         download_span = download_span.subspan(image.unswizzled_size_bytes);
     }
@@ -734,13 +743,21 @@ void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging)
         gpu_memory->ReadBlockUnsafe(gpu_addr, mapped_span.data(), mapped_span.size_bytes());
         const auto uploads = FullUploadSwizzles(image.info);
         runtime.AccelerateImageUpload(image, staging, uploads);
-    } else if (True(image.flags & ImageFlagBits::Converted)) {
-        std::vector<u8> unswizzled_data(image.unswizzled_size_bytes);
-        auto copies = UnswizzleImage(*gpu_memory, gpu_addr, image.info, unswizzled_data);
-        ConvertImage(unswizzled_data, image.info, mapped_span, copies);
+        return;
+    }
+    const size_t guest_size_bytes = image.guest_size_bytes;
+    swizzle_data_buffer.resize_destructive(guest_size_bytes);
+    gpu_memory->ReadBlockUnsafe(gpu_addr, swizzle_data_buffer.data(), guest_size_bytes);
+
+    if (True(image.flags & ImageFlagBits::Converted)) {
+        unswizzle_data_buffer.resize_destructive(image.unswizzled_size_bytes);
+        auto copies = UnswizzleImage(*gpu_memory, gpu_addr, image.info, swizzle_data_buffer,
+                                     unswizzle_data_buffer);
+        ConvertImage(unswizzle_data_buffer, image.info, mapped_span, copies);
         image.UploadMemory(staging, copies);
     } else {
-        const auto copies = UnswizzleImage(*gpu_memory, gpu_addr, image.info, mapped_span);
+        const auto copies =
+            UnswizzleImage(*gpu_memory, gpu_addr, image.info, swizzle_data_buffer, mapped_span);
         image.UploadMemory(staging, copies);
     }
 }
@@ -910,7 +927,7 @@ void TextureCache<P>::InvalidateScale(Image& image) {
 }
 
 template <class P>
-u64 TextureCache<P>::GetScaledImageSizeBytes(ImageBase& image) {
+u64 TextureCache<P>::GetScaledImageSizeBytes(const ImageBase& image) {
     const u64 scale_up = static_cast<u64>(Settings::values.resolution_info.up_scale *
                                           Settings::values.resolution_info.up_scale);
     const u64 down_shift = static_cast<u64>(Settings::values.resolution_info.down_shift +

src/video_core/texture_cache/texture_cache_base.h

@@ -17,6 +17,7 @@
 #include "common/literals.h"
 #include "common/lru_cache.h"
 #include "common/polyfill_ranges.h"
+#include "common/scratch_buffer.h"
 #include "video_core/compatible_formats.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
@@ -368,7 +369,7 @@ private:
     void InvalidateScale(Image& image);
     bool ScaleUp(Image& image);
     bool ScaleDown(Image& image);
-    u64 GetScaledImageSizeBytes(ImageBase& image);
+    u64 GetScaledImageSizeBytes(const ImageBase& image);
 
     Runtime& runtime;
 
@@ -417,6 +418,9 @@ private:
 
     std::unordered_map<GPUVAddr, ImageAllocId> image_allocs_table;
 
+    Common::ScratchBuffer<u8> swizzle_data_buffer;
+    Common::ScratchBuffer<u8> unswizzle_data_buffer;
+
     u64 modification_tick = 0;
     u64 frame_tick = 0;
 };

src/video_core/texture_cache/util.cpp

@@ -505,7 +505,7 @@ void SwizzlePitchLinearImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr
 
 void SwizzleBlockLinearImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr,
                              const ImageInfo& info, const BufferImageCopy& copy,
-                             std::span<const u8> input) {
+                             std::span<const u8> input, Common::ScratchBuffer<u8>& tmp_buffer) {
     const Extent3D size = info.size;
     const LevelInfo level_info = MakeLevelInfo(info);
     const Extent2D tile_size = DefaultBlockSize(info.format);
@@ -534,8 +534,8 @@ void SwizzleBlockLinearImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr
                        tile_size.height, info.tile_width_spacing);
     const size_t subresource_size = sizes[level];
 
-    const auto dst_data = std::make_unique<u8[]>(subresource_size);
-    const std::span<u8> dst(dst_data.get(), subresource_size);
+    tmp_buffer.resize_destructive(subresource_size);
+    const std::span<u8> dst(tmp_buffer);
 
     for (s32 layer = 0; layer < info.resources.layers; ++layer) {
         const std::span<const u8> src = input.subspan(host_offset);
@@ -765,8 +765,9 @@ bool IsValidEntry(const Tegra::MemoryManager& gpu_memory, const TICEntry& config
 }
 
 std::vector<BufferImageCopy> UnswizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr,
-                                            const ImageInfo& info, std::span<u8> output) {
-    const size_t guest_size_bytes = CalculateGuestSizeInBytes(info);
+                                            const ImageInfo& info, std::span<const u8> input,
+                                            std::span<u8> output) {
+    const size_t guest_size_bytes = input.size_bytes();
     const u32 bpp_log2 = BytesPerBlockLog2(info.format);
     const Extent3D size = info.size;
 
@@ -789,10 +790,6 @@ std::vector<BufferImageCopy> UnswizzleImage(Tegra::MemoryManager& gpu_memory, GP
             .image_extent = size,
         }};
     }
-    const auto input_data = std::make_unique<u8[]>(guest_size_bytes);
-    gpu_memory.ReadBlockUnsafe(gpu_addr, input_data.get(), guest_size_bytes);
-    const std::span<const u8> input(input_data.get(), guest_size_bytes);
-
     const LevelInfo level_info = MakeLevelInfo(info);
     const s32 num_layers = info.resources.layers;
     const s32 num_levels = info.resources.levels;
@@ -980,13 +977,14 @@ std::vector<SwizzleParameters> FullUploadSwizzles(const ImageInfo& info) {
 }
 
 void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const ImageInfo& info,
-                  std::span<const BufferImageCopy> copies, std::span<const u8> memory) {
+                  std::span<const BufferImageCopy> copies, std::span<const u8> memory,
+                  Common::ScratchBuffer<u8>& tmp_buffer) {
     const bool is_pitch_linear = info.type == ImageType::Linear;
     for (const BufferImageCopy& copy : copies) {
         if (is_pitch_linear) {
             SwizzlePitchLinearImage(gpu_memory, gpu_addr, info, copy, memory);
         } else {
-            SwizzleBlockLinearImage(gpu_memory, gpu_addr, info, copy, memory);
+            SwizzleBlockLinearImage(gpu_memory, gpu_addr, info, copy, memory, tmp_buffer);
         }
     }
 }

src/video_core/texture_cache/util.h

@@ -7,6 +7,7 @@
 #include <span>
 
 #include "common/common_types.h"
+#include "common/scratch_buffer.h"
 
 #include "video_core/surface.h"
 #include "video_core/texture_cache/image_base.h"
@@ -59,6 +60,7 @@ struct OverlapResult {
 
 [[nodiscard]] std::vector<BufferImageCopy> UnswizzleImage(Tegra::MemoryManager& gpu_memory,
                                                           GPUVAddr gpu_addr, const ImageInfo& info,
+                                                          std::span<const u8> input,
                                                           std::span<u8> output);
 
 [[nodiscard]] BufferCopy UploadBufferCopy(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr,
@@ -76,7 +78,8 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
 [[nodiscard]] std::vector<SwizzleParameters> FullUploadSwizzles(const ImageInfo& info);
 
 void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const ImageInfo& info,
-                  std::span<const BufferImageCopy> copies, std::span<const u8> memory);
+                  std::span<const BufferImageCopy> copies, std::span<const u8> memory,
+                  Common::ScratchBuffer<u8>& tmp_buffer);
 
 [[nodiscard]] bool IsBlockLinearSizeCompatible(const ImageInfo& new_info,
                                                const ImageInfo& overlap_info, u32 new_level,

src/yuzu/configuration/configure_input_player.cpp

@@ -738,13 +738,10 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
     connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
             &ConfigureInputPlayer::UpdateMappingWithDefaults);
+    ui->comboDevices->installEventFilter(this);
 
     ui->comboDevices->setCurrentIndex(-1);
 
-    ui->buttonRefreshDevices->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
-    connect(ui->buttonRefreshDevices, &QPushButton::clicked,
-            [this] { emit RefreshInputDevices(); });
-
     timeout_timer->setSingleShot(true);
     connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
 
@@ -1479,6 +1476,13 @@ void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
     }
 }
 
+bool ConfigureInputPlayer::eventFilter(QObject* object, QEvent* event) {
+    if (object == ui->comboDevices && event->type() == QEvent::MouseButtonPress) {
+        RefreshInputDevices();
+    }
+    return object->eventFilter(object, event);
+}
+
 void ConfigureInputPlayer::CreateProfile() {
     const auto profile_name =
         LimitableInputDialog::GetText(this, tr("New Profile"), tr("Enter a profile name:"), 1, 30,

src/yuzu/configuration/configure_input_player.h

@@ -119,6 +119,9 @@ private:
     /// Handle key press events.
     void keyPressEvent(QKeyEvent* event) override;
 
+    /// Handle combobox list refresh
+    bool eventFilter(QObject* object, QEvent* event) override;
+
     /// Update UI to reflect current configuration.
     void UpdateUI();
 

src/yuzu/configuration/configure_input_player.ui

@@ -122,25 +122,6 @@
             </property>
            </widget>
           </item>
-          <item>
-           <widget class="QPushButton" name="buttonRefreshDevices">
-            <property name="minimumSize">
-             <size>
-              <width>21</width>
-              <height>21</height>
-             </size>
-            </property>
-            <property name="maximumSize">
-             <size>
-              <width>21</width>
-              <height>21</height>
-             </size>
-            </property>
-            <property name="styleSheet">
-             <string notr="true"/>
-            </property>
-           </widget>
-          </item>
          </layout>
         </widget>
        </item>