23 files changed, 211 insertions, 192 deletions

diff --git a/src/common/cache_management.cpp b/src/common/cache_management.cpp
index 57810b76a..ed353828a 100644
--- a/src/common/cache_management.cpp
+++ b/src/common/cache_management.cpp
@@ -1,11 +1,10 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <cstdint>
 #include <cstring>
 
-#include "alignment.h"
-#include "cache_management.h"
-#include "common_types.h"
+#include "common/cache_management.h"
 
 namespace Common {
 
diff --git a/src/common/cache_management.h b/src/common/cache_management.h
index e467b87e4..038323e95 100644
--- a/src/common/cache_management.h
+++ b/src/common/cache_management.h
@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "stdlib.h"
+#include <cstddef>
 
 namespace Common {
 
diff --git a/src/common/input.h b/src/common/input.h
index cb30b7254..449e0193f 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -383,6 +383,16 @@ void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDevic
     }
 }
 
+inline void RegisterInputFactory(const std::string& name,
+                                 std::shared_ptr<Factory<InputDevice>> factory) {
+    RegisterFactory<InputDevice>(name, std::move(factory));
+}
+
+inline void RegisterOutputFactory(const std::string& name,
+                                  std::shared_ptr<Factory<OutputDevice>> factory) {
+    RegisterFactory<OutputDevice>(name, std::move(factory));
+}
+
 /**
  * Unregisters an input device factory.
  * @tparam InputDeviceType the type of input devices the factory can create
@@ -395,6 +405,14 @@ void UnregisterFactory(const std::string& name) {
     }
 }
 
+inline void UnregisterInputFactory(const std::string& name) {
+    UnregisterFactory<InputDevice>(name);
+}
+
+inline void UnregisterOutputFactory(const std::string& name) {
+    UnregisterFactory<OutputDevice>(name);
+}
+
 /**
  * Create an input device from given paramters.
  * @tparam InputDeviceType the type of input devices to create
@@ -416,13 +434,21 @@ std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& param
     return pair->second->Create(package);
 }
 
+inline std::unique_ptr<InputDevice> CreateInputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<InputDevice>(params);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<OutputDevice>(params);
+}
+
 /**
- * Create an input device from given paramters.
+ * Create an input device from given parameters.
  * @tparam InputDeviceType the type of input devices to create
- * @param A ParamPackage that contains all parameters for creating the device
+ * @param package A ParamPackage that contains all parameters for creating the device
  */
 template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
+std::unique_ptr<InputDeviceType> CreateDevice(const ParamPackage& package) {
     const std::string engine = package.Get("engine", "null");
     const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
     const auto pair = factory_list.find(engine);
@@ -435,4 +461,12 @@ std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package
     return pair->second->Create(package);
 }
 
+inline std::unique_ptr<InputDevice> CreateInputDevice(const ParamPackage& package) {
+    return CreateDevice<InputDevice>(package);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDevice(const ParamPackage& package) {
+    return CreateDevice<OutputDevice>(package);
+}
+
 } // namespace Common::Input
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index fb7e5802a..b6c8cc58d 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -68,7 +68,7 @@ void EmulatedConsole::ReloadInput() {
     // If you load any device here add the equivalent to the UnloadInput() function
     SetTouchParams();
 
-    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
+    motion_devices = Common::Input::CreateInputDevice(motion_params);
     if (motion_devices) {
         motion_devices->SetCallback({
             .on_change =
@@ -79,7 +79,7 @@ void EmulatedConsole::ReloadInput() {
     // Unique index for identifying touch device source
     std::size_t index = 0;
     for (auto& touch_device : touch_devices) {
-        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
+        touch_device = Common::Input::CreateInputDevice(touch_params[index]);
         if (!touch_device) {
             continue;
         }
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index ec1364452..c96d9eef3 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
+
 #include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
@@ -144,29 +146,23 @@ void EmulatedController::LoadDevices() {
 
     LoadTASParams();
 
-    std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
-                   button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
-                   button_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(stick_params.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
-                   stick_params.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   stick_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
-                   motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
-                   motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(battery_params.begin(), battery_params.end(), battery_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    camera_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(camera_params);
-    nfc_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(nfc_params);
-    std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
+    std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(motion_params, motion_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(trigger_params, trigger_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(battery_params, battery_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    camera_devices = Common::Input::CreateInputDevice(camera_params);
+    nfc_devices = Common::Input::CreateInputDevice(nfc_params);
+    std::ranges::transform(output_params, output_devices.begin(),
+                           Common::Input::CreateOutputDevice);
 
     // Initialize TAS devices
-    std::transform(tas_button_params.begin(), tas_button_params.end(), tas_button_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(tas_stick_params.begin(), tas_stick_params.end(), tas_stick_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
+    std::ranges::transform(tas_button_params, tas_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }
 
 void EmulatedController::LoadTASParams() {
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index 658dbd318..e421828d2 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -25,12 +25,12 @@ void EmulatedDevices::ReloadInput() {
         Common::ParamPackage mouse_params;
         mouse_params.Set("engine", "mouse");
         mouse_params.Set("button", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
         key_index++;
     }
 
-    mouse_stick_device = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        "engine:mouse,axis_x:0,axis_y:1");
+    mouse_stick_device =
+        Common::Input::CreateInputDeviceFromString("engine:mouse,axis_x:0,axis_y:1");
 
     // First two axis are reserved for mouse position
     key_index = 2;
@@ -38,7 +38,7 @@ void EmulatedDevices::ReloadInput() {
         Common::ParamPackage mouse_params;
         mouse_params.Set("engine", "mouse");
         mouse_params.Set("axis", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
         key_index++;
     }
 
@@ -50,7 +50,7 @@ void EmulatedDevices::ReloadInput() {
         keyboard_params.Set("button", static_cast<int>(key_index));
         keyboard_params.Set("port", 1);
         keyboard_params.Set("pad", 0);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
         key_index++;
     }
 
@@ -62,11 +62,11 @@ void EmulatedDevices::ReloadInput() {
         keyboard_params.Set("button", static_cast<int>(key_index));
         keyboard_params.Set("port", 1);
         keyboard_params.Set("pad", 1);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
         key_index++;
     }
 
-    ring_analog_device = Common::Input::CreateDevice<Common::Input::InputDevice>(ring_params);
+    ring_analog_device = Common::Input::CreateInputDevice(ring_params);
 
     for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
         if (!mouse_button_devices[index]) {
diff --git a/src/core/hle/service/nvdrv/core/syncpoint_manager.cpp b/src/core/hle/service/nvdrv/core/syncpoint_manager.cpp
index eda2041a0..aba51d280 100644
--- a/src/core/hle/service/nvdrv/core/syncpoint_manager.cpp
+++ b/src/core/hle/service/nvdrv/core/syncpoint_manager.cpp
@@ -28,13 +28,15 @@ SyncpointManager::SyncpointManager(Tegra::Host1x::Host1x& host1x_) : host1x{host
 SyncpointManager::~SyncpointManager() = default;
 
 u32 SyncpointManager::ReserveSyncpoint(u32 id, bool client_managed) {
-    if (syncpoints.at(id).reserved) {
+    auto& syncpoint = syncpoints.at(id);
+
+    if (syncpoint.reserved) {
         ASSERT_MSG(false, "Requested syncpoint is in use");
         return 0;
     }
 
-    syncpoints.at(id).reserved = true;
-    syncpoints.at(id).interface_managed = client_managed;
+    syncpoint.reserved = true;
+    syncpoint.interface_managed = client_managed;
 
     return id;
 }
@@ -56,11 +58,12 @@ u32 SyncpointManager::AllocateSyncpoint(bool client_managed) {
 
 void SyncpointManager::FreeSyncpoint(u32 id) {
     std::lock_guard lock(reservation_lock);
-    ASSERT(syncpoints.at(id).reserved);
-    syncpoints.at(id).reserved = false;
+    auto& syncpoint = syncpoints.at(id);
+    ASSERT(syncpoint.reserved);
+    syncpoint.reserved = false;
 }
 
-bool SyncpointManager::IsSyncpointAllocated(u32 id) {
+bool SyncpointManager::IsSyncpointAllocated(u32 id) const {
     return (id <= SyncpointCount) && syncpoints[id].reserved;
 }
 
@@ -69,7 +72,7 @@ bool SyncpointManager::HasSyncpointExpired(u32 id, u32 threshold) const {
 
     if (!syncpoint.reserved) {
         ASSERT(false);
-        return 0;
+        return false;
     }
 
     // If the interface manages counters then we don't keep track of the maximum value as it handles
@@ -82,40 +85,51 @@ bool SyncpointManager::HasSyncpointExpired(u32 id, u32 threshold) const {
 }
 
 u32 SyncpointManager::IncrementSyncpointMaxExt(u32 id, u32 amount) {
-    if (!syncpoints.at(id).reserved) {
+    auto& syncpoint = syncpoints.at(id);
+
+    if (!syncpoint.reserved) {
         ASSERT(false);
         return 0;
     }
 
-    return syncpoints.at(id).counter_max += amount;
+    return syncpoint.counter_max += amount;
 }
 
 u32 SyncpointManager::ReadSyncpointMinValue(u32 id) {
-    if (!syncpoints.at(id).reserved) {
+    auto& syncpoint = syncpoints.at(id);
+
+    if (!syncpoint.reserved) {
         ASSERT(false);
         return 0;
     }
 
-    return syncpoints.at(id).counter_min;
+    return syncpoint.counter_min;
 }
 
 u32 SyncpointManager::UpdateMin(u32 id) {
-    if (!syncpoints.at(id).reserved) {
+    auto& syncpoint = syncpoints.at(id);
+
+    if (!syncpoint.reserved) {
         ASSERT(false);
         return 0;
     }
 
-    syncpoints.at(id).counter_min = host1x.GetSyncpointManager().GetHostSyncpointValue(id);
-    return syncpoints.at(id).counter_min;
+    syncpoint.counter_min = host1x.GetSyncpointManager().GetHostSyncpointValue(id);
+    return syncpoint.counter_min;
 }
 
 NvFence SyncpointManager::GetSyncpointFence(u32 id) {
-    if (!syncpoints.at(id).reserved) {
+    auto& syncpoint = syncpoints.at(id);
+
+    if (!syncpoint.reserved) {
         ASSERT(false);
         return NvFence{};
     }
 
-    return {.id = static_cast<s32>(id), .value = syncpoints.at(id).counter_max};
+    return {
+        .id = static_cast<s32>(id),
+        .value = syncpoint.counter_max,
+    };
 }
 
 } // namespace Service::Nvidia::NvCore
diff --git a/src/core/hle/service/nvdrv/core/syncpoint_manager.h b/src/core/hle/service/nvdrv/core/syncpoint_manager.h
index b76ef9032..4f2cefae5 100644
--- a/src/core/hle/service/nvdrv/core/syncpoint_manager.h
+++ b/src/core/hle/service/nvdrv/core/syncpoint_manager.h
@@ -44,7 +44,7 @@ public:
     /**
      * @brief Checks if the given syncpoint is both allocated and below the number of HW syncpoints
      */
-    bool IsSyncpointAllocated(u32 id);
+    bool IsSyncpointAllocated(u32 id) const;
 
     /**
      * @brief Finds a free syncpoint and reserves it
diff --git a/src/core/hle/service/nvdrv/nvdrv.cpp b/src/core/hle/service/nvdrv/nvdrv.cpp
index 9f4c7c99a..6fc8565c0 100644
--- a/src/core/hle/service/nvdrv/nvdrv.cpp
+++ b/src/core/hle/service/nvdrv/nvdrv.cpp
@@ -55,48 +55,40 @@ void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger
 Module::Module(Core::System& system)
     : container{system.Host1x()}, service_context{system, "nvdrv"}, events_interface{*this} {
     builders["/dev/nvhost-as-gpu"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_as_gpu>(system, *this, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_as_gpu>(system, *this, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-gpu"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_gpu>(system, events_interface, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_gpu>(system, events_interface, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-ctrl-gpu"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_ctrl_gpu>(system, events_interface);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_ctrl_gpu>(system, events_interface);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvmap"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvmap>(system, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvmap>(system, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvdisp_disp0"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvdisp_disp0>(system, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvdisp_disp0>(system, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-ctrl"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_ctrl>(system, events_interface, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_ctrl>(system, events_interface, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-nvdec"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_nvdec>(system, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_nvdec>(system, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-nvjpg"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device = std::make_shared<Devices::nvhost_nvjpg>(system);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_nvjpg>(system);
+        return open_files.emplace(fd, std::move(device)).first;
     };
     builders["/dev/nvhost-vic"] = [this, &system](DeviceFD fd) {
-        std::shared_ptr<Devices::nvdevice> device =
-            std::make_shared<Devices::nvhost_vic>(system, container);
-        return open_files.emplace(fd, device).first;
+        auto device = std::make_shared<Devices::nvhost_vic>(system, container);
+        return open_files.emplace(fd, std::move(device)).first;
     };
 }
 
diff --git a/src/core/hle/service/nvflinger/buffer_item_consumer.cpp b/src/core/hle/service/nvflinger/buffer_item_consumer.cpp
index 6d2c92a2c..152bb5bdf 100644
--- a/src/core/hle/service/nvflinger/buffer_item_consumer.cpp
+++ b/src/core/hle/service/nvflinger/buffer_item_consumer.cpp
@@ -39,7 +39,7 @@ Status BufferItemConsumer::AcquireBuffer(BufferItem* item, std::chrono::nanoseco
     return Status::NoError;
 }
 
-Status BufferItemConsumer::ReleaseBuffer(const BufferItem& item, Fence& release_fence) {
+Status BufferItemConsumer::ReleaseBuffer(const BufferItem& item, const Fence& release_fence) {
     std::scoped_lock lock{mutex};
 
     if (const auto status = AddReleaseFenceLocked(item.buf, item.graphic_buffer, release_fence);
diff --git a/src/core/hle/service/nvflinger/buffer_item_consumer.h b/src/core/hle/service/nvflinger/buffer_item_consumer.h
index 69046233d..a5c655d9e 100644
--- a/src/core/hle/service/nvflinger/buffer_item_consumer.h
+++ b/src/core/hle/service/nvflinger/buffer_item_consumer.h
@@ -22,7 +22,7 @@ public:
     explicit BufferItemConsumer(std::unique_ptr<BufferQueueConsumer> consumer);
     Status AcquireBuffer(BufferItem* item, std::chrono::nanoseconds present_when,
                          bool wait_for_fence = true);
-    Status ReleaseBuffer(const BufferItem& item, Fence& release_fence);
+    Status ReleaseBuffer(const BufferItem& item, const Fence& release_fence);
 };
 
 } // namespace Service::android
diff --git a/src/core/hle/service/nvflinger/buffer_queue_consumer.cpp b/src/core/hle/service/nvflinger/buffer_queue_consumer.cpp
index 1ce67c771..0767e548d 100644
--- a/src/core/hle/service/nvflinger/buffer_queue_consumer.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue_consumer.cpp
@@ -169,7 +169,7 @@ Status BufferQueueConsumer::Connect(std::shared_ptr<IConsumerListener> consumer_
         return Status::NoInit;
     }
 
-    core->consumer_listener = consumer_listener;
+    core->consumer_listener = std::move(consumer_listener);
     core->consumer_controlled_by_app = controlled_by_app;
 
     return Status::NoError;
diff --git a/src/core/hle/service/nvflinger/consumer_base.cpp b/src/core/hle/service/nvflinger/consumer_base.cpp
index 5b9995854..982531e2d 100644
--- a/src/core/hle/service/nvflinger/consumer_base.cpp
+++ b/src/core/hle/service/nvflinger/consumer_base.cpp
@@ -83,7 +83,7 @@ Status ConsumerBase::AcquireBufferLocked(BufferItem* item, std::chrono::nanoseco
 }
 
 Status ConsumerBase::AddReleaseFenceLocked(s32 slot,
-                                           const std::shared_ptr<GraphicBuffer> graphic_buffer,
+                                           const std::shared_ptr<GraphicBuffer>& graphic_buffer,
                                            const Fence& fence) {
     LOG_DEBUG(Service_NVFlinger, "slot={}", slot);
 
@@ -100,7 +100,7 @@ Status ConsumerBase::AddReleaseFenceLocked(s32 slot,
 }
 
 Status ConsumerBase::ReleaseBufferLocked(s32 slot,
-                                         const std::shared_ptr<GraphicBuffer> graphic_buffer) {
+                                         const std::shared_ptr<GraphicBuffer>& graphic_buffer) {
     // If consumer no longer tracks this graphic_buffer (we received a new
     // buffer on the same slot), the buffer producer is definitely no longer
     // tracking it.
@@ -121,7 +121,7 @@ Status ConsumerBase::ReleaseBufferLocked(s32 slot,
 }
 
 bool ConsumerBase::StillTracking(s32 slot,
-                                 const std::shared_ptr<GraphicBuffer> graphic_buffer) const {
+                                 const std::shared_ptr<GraphicBuffer>& graphic_buffer) const {
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
         return false;
     }
diff --git a/src/core/hle/service/nvflinger/consumer_base.h b/src/core/hle/service/nvflinger/consumer_base.h
index 90ba07f45..9a8a5f6bb 100644
--- a/src/core/hle/service/nvflinger/consumer_base.h
+++ b/src/core/hle/service/nvflinger/consumer_base.h
@@ -27,18 +27,18 @@ public:
 
 protected:
     explicit ConsumerBase(std::unique_ptr<BufferQueueConsumer> consumer_);
-    virtual ~ConsumerBase();
+    ~ConsumerBase() override;
 
-    virtual void OnFrameAvailable(const BufferItem& item) override;
-    virtual void OnFrameReplaced(const BufferItem& item) override;
-    virtual void OnBuffersReleased() override;
-    virtual void OnSidebandStreamChanged() override;
+    void OnFrameAvailable(const BufferItem& item) override;
+    void OnFrameReplaced(const BufferItem& item) override;
+    void OnBuffersReleased() override;
+    void OnSidebandStreamChanged() override;
 
     void FreeBufferLocked(s32 slot_index);
     Status AcquireBufferLocked(BufferItem* item, std::chrono::nanoseconds present_when);
-    Status ReleaseBufferLocked(s32 slot, const std::shared_ptr<GraphicBuffer> graphic_buffer);
-    bool StillTracking(s32 slot, const std::shared_ptr<GraphicBuffer> graphic_buffer) const;
-    Status AddReleaseFenceLocked(s32 slot, const std::shared_ptr<GraphicBuffer> graphic_buffer,
+    Status ReleaseBufferLocked(s32 slot, const std::shared_ptr<GraphicBuffer>& graphic_buffer);
+    bool StillTracking(s32 slot, const std::shared_ptr<GraphicBuffer>& graphic_buffer) const;
+    Status AddReleaseFenceLocked(s32 slot, const std::shared_ptr<GraphicBuffer>& graphic_buffer,
                                  const Fence& fence);
 
     struct Slot final {
diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp
index c3af12c90..d1cbadde4 100644
--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -307,8 +307,7 @@ void NVFlinger::Compose() {
 
         swap_interval = buffer.swap_interval;
 
-        auto fence = android::Fence::NoFence();
-        layer.GetConsumer().ReleaseBuffer(buffer, fence);
+        layer.GetConsumer().ReleaseBuffer(buffer, android::Fence::NoFence());
     }
 }
 
diff --git a/src/core/hle/service/nvflinger/producer_listener.h b/src/core/hle/service/nvflinger/producer_listener.h
index 1c4d5db0e..6bf8aaf1e 100644
--- a/src/core/hle/service/nvflinger/producer_listener.h
+++ b/src/core/hle/service/nvflinger/producer_listener.h
@@ -10,6 +10,7 @@ namespace Service::android {
 
 class IProducerListener {
 public:
+    virtual ~IProducerListener() = default;
     virtual void OnBufferReleased() = 0;
 };
 
diff --git a/src/input_common/helpers/stick_from_buttons.cpp b/src/input_common/helpers/stick_from_buttons.cpp
index 536d413a5..82aa6ac2f 100644
--- a/src/input_common/helpers/stick_from_buttons.cpp
+++ b/src/input_common/helpers/stick_from_buttons.cpp
@@ -294,6 +294,15 @@ public:
     }
 
 private:
+    static constexpr Common::Input::AnalogProperties properties{
+        .deadzone = 0.0f,
+        .range = 1.0f,
+        .threshold = 0.5f,
+        .offset = 0.0f,
+        .inverted = false,
+        .toggle = false,
+    };
+
     Button up;
     Button down;
     Button left;
@@ -311,23 +320,17 @@ private:
     float last_x_axis_value{};
     float last_y_axis_value{};
     Common::Input::ButtonStatus modifier_status{};
-    const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 };
 
 std::unique_ptr<Common::Input::InputDevice> StickFromButton::Create(
     const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
-    auto up = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("up", null_engine));
-    auto down = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("down", null_engine));
-    auto left = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("left", null_engine));
-    auto right = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("right", null_engine));
-    auto modifier = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("modifier", null_engine));
+    auto up = Common::Input::CreateInputDeviceFromString(params.Get("up", null_engine));
+    auto down = Common::Input::CreateInputDeviceFromString(params.Get("down", null_engine));
+    auto left = Common::Input::CreateInputDeviceFromString(params.Get("left", null_engine));
+    auto right = Common::Input::CreateInputDeviceFromString(params.Get("right", null_engine));
+    auto modifier = Common::Input::CreateInputDeviceFromString(params.Get("modifier", null_engine));
     auto modifier_scale = params.Get("modifier_scale", 0.5f);
     auto modifier_angle = params.Get("modifier_angle", 5.5f);
     return std::make_unique<Stick>(std::move(up), std::move(down), std::move(left),
diff --git a/src/input_common/helpers/touch_from_buttons.cpp b/src/input_common/helpers/touch_from_buttons.cpp
index 003a38da5..e064b13d9 100644
--- a/src/input_common/helpers/touch_from_buttons.cpp
+++ b/src/input_common/helpers/touch_from_buttons.cpp
@@ -59,18 +59,25 @@ public:
     }
 
 private:
+    static constexpr Common::Input::AnalogProperties properties{
+        .deadzone = 0.0f,
+        .range = 1.0f,
+        .threshold = 0.5f,
+        .offset = 0.0f,
+        .inverted = false,
+        .toggle = false,
+    };
+
     Button button;
     bool last_button_value;
     const float x;
     const float y;
-    const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
 };
 
 std::unique_ptr<Common::Input::InputDevice> TouchFromButton::Create(
     const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
-    auto button = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        params.Get("button", null_engine));
+    auto button = Common::Input::CreateInputDeviceFromString(params.Get("button", null_engine));
     const float x = params.Get("x", 0.0f) / 1280.0f;
     const float y = params.Get("y", 0.0f) / 720.0f;
     return std::make_unique<TouchFromButtonDevice>(std::move(button), x, y);
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 76df133f3..baeed2e02 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -33,129 +33,113 @@ struct InputSubsystem::Impl {
         keyboard->SetMappingCallback(mapping_callback);
         keyboard_factory = std::make_shared<InputFactory>(keyboard);
         keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName(),
-                                                                   keyboard_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(keyboard->GetEngineName(),
-                                                                    keyboard_output_factory);
+        Common::Input::RegisterInputFactory(keyboard->GetEngineName(), keyboard_factory);
+        Common::Input::RegisterOutputFactory(keyboard->GetEngineName(), keyboard_output_factory);
 
         mouse = std::make_shared<Mouse>("mouse");
         mouse->SetMappingCallback(mapping_callback);
         mouse_factory = std::make_shared<InputFactory>(mouse);
         mouse_output_factory = std::make_shared<OutputFactory>(mouse);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(mouse->GetEngineName(),
-                                                                   mouse_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName(),
-                                                                    mouse_output_factory);
+        Common::Input::RegisterInputFactory(mouse->GetEngineName(), mouse_factory);
+        Common::Input::RegisterOutputFactory(mouse->GetEngineName(), mouse_output_factory);
 
         touch_screen = std::make_shared<TouchScreen>("touch");
         touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(touch_screen->GetEngineName(),
-                                                                   touch_screen_factory);
+        Common::Input::RegisterInputFactory(touch_screen->GetEngineName(), touch_screen_factory);
 
         gcadapter = std::make_shared<GCAdapter>("gcpad");
         gcadapter->SetMappingCallback(mapping_callback);
         gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
         gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName(),
-                                                                   gcadapter_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName(),
-                                                                    gcadapter_output_factory);
+        Common::Input::RegisterInputFactory(gcadapter->GetEngineName(), gcadapter_input_factory);
+        Common::Input::RegisterOutputFactory(gcadapter->GetEngineName(), gcadapter_output_factory);
 
         udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
         udp_client->SetMappingCallback(mapping_callback);
         udp_client_input_factory = std::make_shared<InputFactory>(udp_client);
         udp_client_output_factory = std::make_shared<OutputFactory>(udp_client);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName(),
-                                                                   udp_client_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(udp_client->GetEngineName(),
-                                                                    udp_client_output_factory);
+        Common::Input::RegisterInputFactory(udp_client->GetEngineName(), udp_client_input_factory);
+        Common::Input::RegisterOutputFactory(udp_client->GetEngineName(),
+                                             udp_client_output_factory);
 
         tas_input = std::make_shared<TasInput::Tas>("tas");
         tas_input->SetMappingCallback(mapping_callback);
         tas_input_factory = std::make_shared<InputFactory>(tas_input);
         tas_output_factory = std::make_shared<OutputFactory>(tas_input);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName(),
-                                                                   tas_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName(),
-                                                                    tas_output_factory);
+        Common::Input::RegisterInputFactory(tas_input->GetEngineName(), tas_input_factory);
+        Common::Input::RegisterOutputFactory(tas_input->GetEngineName(), tas_output_factory);
 
         camera = std::make_shared<Camera>("camera");
         camera->SetMappingCallback(mapping_callback);
         camera_input_factory = std::make_shared<InputFactory>(camera);
         camera_output_factory = std::make_shared<OutputFactory>(camera);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(camera->GetEngineName(),
-                                                                   camera_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(camera->GetEngineName(),
-                                                                    camera_output_factory);
+        Common::Input::RegisterInputFactory(camera->GetEngineName(), camera_input_factory);
+        Common::Input::RegisterOutputFactory(camera->GetEngineName(), camera_output_factory);
 
         virtual_amiibo = std::make_shared<VirtualAmiibo>("virtual_amiibo");
         virtual_amiibo->SetMappingCallback(mapping_callback);
         virtual_amiibo_input_factory = std::make_shared<InputFactory>(virtual_amiibo);
         virtual_amiibo_output_factory = std::make_shared<OutputFactory>(virtual_amiibo);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(virtual_amiibo->GetEngineName(),
-                                                                   virtual_amiibo_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(virtual_amiibo->GetEngineName(),
-                                                                    virtual_amiibo_output_factory);
+        Common::Input::RegisterInputFactory(virtual_amiibo->GetEngineName(),
+                                            virtual_amiibo_input_factory);
+        Common::Input::RegisterOutputFactory(virtual_amiibo->GetEngineName(),
+                                             virtual_amiibo_output_factory);
 
 #ifdef HAVE_SDL2
         sdl = std::make_shared<SDLDriver>("sdl");
         sdl->SetMappingCallback(mapping_callback);
         sdl_input_factory = std::make_shared<InputFactory>(sdl);
         sdl_output_factory = std::make_shared<OutputFactory>(sdl);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(sdl->GetEngineName(),
-                                                                   sdl_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName(),
-                                                                    sdl_output_factory);
+        Common::Input::RegisterInputFactory(sdl->GetEngineName(), sdl_input_factory);
+        Common::Input::RegisterOutputFactory(sdl->GetEngineName(), sdl_output_factory);
 #endif
 
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(
-            "touch_from_button", std::make_shared<TouchFromButton>());
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(
-            "analog_from_button", std::make_shared<StickFromButton>());
+        Common::Input::RegisterInputFactory("touch_from_button",
+                                            std::make_shared<TouchFromButton>());
+        Common::Input::RegisterInputFactory("analog_from_button",
+                                            std::make_shared<StickFromButton>());
     }
 
     void Shutdown() {
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(keyboard->GetEngineName());
+        Common::Input::UnregisterInputFactory(keyboard->GetEngineName());
+        Common::Input::UnregisterOutputFactory(keyboard->GetEngineName());
         keyboard.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(mouse->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName());
+        Common::Input::UnregisterInputFactory(mouse->GetEngineName());
+        Common::Input::UnregisterOutputFactory(mouse->GetEngineName());
         mouse.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(touch_screen->GetEngineName());
+        Common::Input::UnregisterInputFactory(touch_screen->GetEngineName());
         touch_screen.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName());
+        Common::Input::UnregisterInputFactory(gcadapter->GetEngineName());
+        Common::Input::UnregisterOutputFactory(gcadapter->GetEngineName());
         gcadapter.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(udp_client->GetEngineName());
+        Common::Input::UnregisterInputFactory(udp_client->GetEngineName());
+        Common::Input::UnregisterOutputFactory(udp_client->GetEngineName());
         udp_client.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName());
+        Common::Input::UnregisterInputFactory(tas_input->GetEngineName());
+        Common::Input::UnregisterOutputFactory(tas_input->GetEngineName());
         tas_input.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(camera->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(camera->GetEngineName());
+        Common::Input::UnregisterInputFactory(camera->GetEngineName());
+        Common::Input::UnregisterOutputFactory(camera->GetEngineName());
         camera.reset();
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(
-            virtual_amiibo->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(
-            virtual_amiibo->GetEngineName());
+        Common::Input::UnregisterInputFactory(virtual_amiibo->GetEngineName());
+        Common::Input::UnregisterOutputFactory(virtual_amiibo->GetEngineName());
         virtual_amiibo.reset();
 
 #ifdef HAVE_SDL2
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>(sdl->GetEngineName());
-        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName());
+        Common::Input::UnregisterInputFactory(sdl->GetEngineName());
+        Common::Input::UnregisterOutputFactory(sdl->GetEngineName());
         sdl.reset();
 #endif
 
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>("touch_from_button");
-        Common::Input::UnregisterFactory<Common::Input::InputDevice>("analog_from_button");
+        Common::Input::UnregisterInputFactory("touch_from_button");
+        Common::Input::UnregisterInputFactory("analog_from_button");
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
diff --git a/src/video_core/host1x/syncpoint_manager.cpp b/src/video_core/host1x/syncpoint_manager.cpp
index a44fc83d3..8f23ce527 100644
--- a/src/video_core/host1x/syncpoint_manager.cpp
+++ b/src/video_core/host1x/syncpoint_manager.cpp
@@ -34,7 +34,7 @@ SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
 }
 
 void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_storage,
-                                        ActionHandle& handle) {
+                                        const ActionHandle& handle) {
     std::unique_lock lk(guard);
 
     // We want to ensure the iterator still exists prior to erasing it
@@ -49,11 +49,11 @@ void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_stor
     }
 }
 
-void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, ActionHandle& handle) {
+void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle) {
     DeregisterAction(guest_action_storage[syncpoint_id], handle);
 }
 
-void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, ActionHandle& handle) {
+void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle) {
     DeregisterAction(host_action_storage[syncpoint_id], handle);
 }
 
diff --git a/src/video_core/host1x/syncpoint_manager.h b/src/video_core/host1x/syncpoint_manager.h
index 50a264e23..847ed20c8 100644
--- a/src/video_core/host1x/syncpoint_manager.h
+++ b/src/video_core/host1x/syncpoint_manager.h
@@ -36,21 +36,19 @@ public:
 
     template <typename Func>
     ActionHandle RegisterGuestAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
-        std::function<void()> func(action);
         return RegisterAction(syncpoints_guest[syncpoint_id], guest_action_storage[syncpoint_id],
-                              expected_value, std::move(func));
+                              expected_value, std::move(action));
     }
 
     template <typename Func>
     ActionHandle RegisterHostAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
-        std::function<void()> func(action);
         return RegisterAction(syncpoints_host[syncpoint_id], host_action_storage[syncpoint_id],
-                              expected_value, std::move(func));
+                              expected_value, std::move(action));
     }
 
-    void DeregisterGuestAction(u32 syncpoint_id, ActionHandle& handle);
+    void DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle);
 
-    void DeregisterHostAction(u32 syncpoint_id, ActionHandle& handle);
+    void DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle);
 
     void IncrementGuest(u32 syncpoint_id);
 
@@ -76,7 +74,7 @@ private:
                                 std::list<RegisteredAction>& action_storage, u32 expected_value,
                                 std::function<void()>&& action);
 
-    void DeregisterAction(std::list<RegisteredAction>& action_storage, ActionHandle& handle);
+    void DeregisterAction(std::list<RegisteredAction>& action_storage, const ActionHandle& handle);
 
     void Wait(std::atomic<u32>& syncpoint, std::condition_variable& wait_cv, u32 expected_value);
 
diff --git a/src/video_core/surface.cpp b/src/video_core/surface.cpp
index b618e1a25..1a76d4178 100644
--- a/src/video_core/surface.cpp
+++ b/src/video_core/surface.cpp
@@ -214,23 +214,16 @@ PixelFormat PixelFormatFromGPUPixelFormat(Service::android::PixelFormat format)
 }
 
 SurfaceType GetFormatType(PixelFormat pixel_format) {
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxColorFormat)) {
+    if (pixel_format < PixelFormat::MaxColorFormat) {
         return SurfaceType::ColorTexture;
     }
-
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxDepthFormat)) {
+    if (pixel_format < PixelFormat::MaxDepthFormat) {
         return SurfaceType::Depth;
     }
-
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxStencilFormat)) {
+    if (pixel_format < PixelFormat::MaxStencilFormat) {
         return SurfaceType::Stencil;
     }
-
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxDepthStencilFormat)) {
+    if (pixel_format < PixelFormat::MaxDepthStencilFormat) {
         return SurfaceType::DepthStencil;
     }
 
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 2aae746f0..346d14252 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -4037,7 +4037,6 @@ void GMainWindow::UpdateUITheme() {
     const QString default_theme =
         QString::fromUtf8(UISettings::themes[static_cast<size_t>(Config::default_theme)].second);
     QString current_theme = UISettings::values.theme;
-    QStringList theme_paths(default_theme_paths);
 
     if (current_theme.isEmpty()) {
         current_theme = default_theme;
@@ -4050,7 +4049,7 @@ void GMainWindow::UpdateUITheme() {
     if (current_theme == QStringLiteral("default") || current_theme == QStringLiteral("colorful")) {
         QIcon::setThemeName(current_theme == QStringLiteral("colorful") ? current_theme
                                                                         : startup_icon_theme);
-        QIcon::setThemeSearchPaths(theme_paths);
+        QIcon::setThemeSearchPaths(QStringList(default_theme_paths));
         if (CheckDarkMode()) {
             current_theme = QStringLiteral("default_dark");
         }