audio/stream: Adjust volume scale factor

src/audio_core/stream.cpp

@@ -79,8 +79,8 @@ static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
         return;
     }
 
-    // Implementation of a volume slider with a dynamic range of 60 dB
-    const float volume_scale_factor = volume == 0 ? 0 : std::exp(6.90775f * volume) * 0.001f;
+    // Perceived volume is not the same as the volume level
+    const float volume_scale_factor = (0.85f * ((volume * volume) - volume)) + volume;
     for (auto& sample : samples) {
         sample = static_cast<s16>(sample * volume_scale_factor);
     }

src/common/fiber.cpp

@@ -124,10 +124,7 @@ void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
 
     // "from" might no longer be valid if the thread was killed
     if (auto from = weak_from.lock()) {
-        if (from->impl->previous_fiber == nullptr) {
-            ASSERT_MSG(false, "previous_fiber is nullptr!");
-            return;
-        }
+        ASSERT(from->impl->previous_fiber != nullptr);
         from->impl->previous_fiber->impl->context = transfer.fctx;
         from->impl->previous_fiber->impl->guard.unlock();
         from->impl->previous_fiber.reset();

src/common/input.h

@@ -209,13 +209,6 @@ enum class ButtonNames {
     Triangle,
     Share,
     Options,
-
-    // Mouse buttons
-    ButtonMouseWheel,
-    ButtonBackward,
-    ButtonForward,
-    ButtonTask,
-    ButtonExtra,
 };
 
 // Callback data consisting of an input type and the equivalent data status

src/core/CMakeLists.txt

@@ -247,9 +247,6 @@ add_library(core STATIC
     hle/kernel/k_trace.h
     hle/kernel/k_transfer_memory.cpp
     hle/kernel/k_transfer_memory.h
-    hle/kernel/k_worker_task.h
-    hle/kernel/k_worker_task_manager.cpp
-    hle/kernel/k_worker_task_manager.h
     hle/kernel/k_writable_event.cpp
     hle/kernel/k_writable_event.h
     hle/kernel/kernel.cpp

src/core/hid/emulated_console.cpp

@@ -158,7 +158,7 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
     auto& motion = console.motion_state;
     motion.accel = emulated.GetAcceleration();
     motion.gyro = emulated.GetGyroscope();
-    motion.rotation = emulated.GetRotations();
+    motion.rotation = emulated.GetGyroscope();
     motion.orientation = emulated.GetOrientation();
     motion.quaternion = emulated.GetQuaternion();
     motion.gyro_bias = emulated.GetGyroBias();

src/core/hid/emulated_controller.cpp

@@ -145,7 +145,7 @@ void EmulatedController::LoadDevices() {
                    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(),
+    std::transform(battery_params.begin(), battery_params.begin(), battery_devices.end(),
                    Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
                    Common::Input::CreateDevice<Common::Input::OutputDevice>);

src/core/hle/kernel/k_process.cpp

@@ -149,10 +149,6 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
     return ResultSuccess;
 }
 
-void KProcess::DoWorkerTaskImpl() {
-    UNIMPLEMENTED();
-}
-
 KResourceLimit* KProcess::GetResourceLimit() const {
     return resource_limit;
 }
@@ -481,7 +477,7 @@ void KProcess::Finalize() {
     }
 
     // Perform inherited finalization.
-    KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask>::Finalize();
+    KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject>::Finalize();
 }
 
 /**

src/core/hle/kernel/k_process.h

@@ -15,7 +15,6 @@
 #include "core/hle/kernel/k_condition_variable.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_synchronization_object.h"
-#include "core/hle/kernel/k_worker_task.h"
 #include "core/hle/kernel/process_capability.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
@@ -63,7 +62,8 @@ enum class ProcessStatus {
     DebugBreak,
 };
 
-class KProcess final : public KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask> {
+class KProcess final
+    : public KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject> {
     KERNEL_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject);
 
 public:
@@ -345,8 +345,6 @@ public:
 
     bool IsSignaled() const override;
 
-    void DoWorkerTaskImpl();
-
     void PinCurrentThread(s32 core_id);
     void UnpinCurrentThread(s32 core_id);
     void UnpinThread(KThread* thread);

src/core/hle/kernel/k_scheduler.cpp

@@ -49,6 +49,8 @@ void KScheduler::RescheduleCores(KernelCore& kernel, u64 cores_pending_reschedul
         if (!must_context_switch || core != current_core) {
             auto& phys_core = kernel.PhysicalCore(core);
             phys_core.Interrupt();
+        } else {
+            must_context_switch = true;
         }
         cores_pending_reschedule &= ~(1ULL << core);
     }

src/core/hle/kernel/k_thread.cpp

@@ -30,7 +30,6 @@
 #include "core/hle/kernel/k_system_control.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_thread_queue.h"
-#include "core/hle/kernel/k_worker_task_manager.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
@@ -333,7 +332,7 @@ void KThread::Finalize() {
     }
 
     // Perform inherited finalization.
-    KSynchronizationObject::Finalize();
+    KAutoObjectWithSlabHeapAndContainer<KThread, KSynchronizationObject>::Finalize();
 }
 
 bool KThread::IsSignaled() const {
@@ -377,28 +376,11 @@ void KThread::StartTermination() {
 
     // Register terminated dpc flag.
     RegisterDpc(DpcFlag::Terminated);
-}
-
-void KThread::FinishTermination() {
-    // Ensure that the thread is not executing on any core.
-    if (parent != nullptr) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) {
-            KThread* core_thread{};
-            do {
-                core_thread = kernel.Scheduler(i).GetCurrentThread();
-            } while (core_thread == this);
-        }
-    }
 
     // Close the thread.
     this->Close();
 }
 
-void KThread::DoWorkerTaskImpl() {
-    // Finish the termination that was begun by Exit().
-    this->FinishTermination();
-}
-
 void KThread::Pin(s32 current_core) {
     ASSERT(kernel.GlobalSchedulerContext().IsLocked());
 
@@ -435,7 +417,12 @@ void KThread::Pin(s32 current_core) {
                                          static_cast<u32>(ThreadState::SuspendShift)));
 
         // Update our state.
-        UpdateState();
+        const ThreadState old_state = thread_state;
+        thread_state = static_cast<ThreadState>(GetSuspendFlags() |
+                                                static_cast<u32>(old_state & ThreadState::Mask));
+        if (thread_state != old_state) {
+            KScheduler::OnThreadStateChanged(kernel, this, old_state);
+        }
     }
 
     // TODO(bunnei): Update our SVC access permissions.
@@ -476,13 +463,20 @@ void KThread::Unpin() {
     }
 
     // Allow performing thread suspension (if termination hasn't been requested).
-    if (!IsTerminationRequested()) {
+    {
         // Update our allow flags.
-        suspend_allowed_flags |= (1 << (static_cast<u32>(SuspendType::Thread) +
-                                        static_cast<u32>(ThreadState::SuspendShift)));
+        if (!IsTerminationRequested()) {
+            suspend_allowed_flags |= (1 << (static_cast<u32>(SuspendType::Thread) +
+                                            static_cast<u32>(ThreadState::SuspendShift)));
+        }
 
         // Update our state.
-        UpdateState();
+        const ThreadState old_state = thread_state;
+        thread_state = static_cast<ThreadState>(GetSuspendFlags() |
+                                                static_cast<u32>(old_state & ThreadState::Mask));
+        if (thread_state != old_state) {
+            KScheduler::OnThreadStateChanged(kernel, this, old_state);
+        }
     }
 
     // TODO(bunnei): Update our SVC access permissions.
@@ -695,7 +689,12 @@ void KThread::Resume(SuspendType type) {
         ~(1u << (static_cast<u32>(ThreadState::SuspendShift) + static_cast<u32>(type)));
 
     // Update our state.
-    this->UpdateState();
+    const ThreadState old_state = thread_state;
+    thread_state = static_cast<ThreadState>(GetSuspendFlags() |
+                                            static_cast<u32>(old_state & ThreadState::Mask));
+    if (thread_state != old_state) {
+        KScheduler::OnThreadStateChanged(kernel, this, old_state);
+    }
 }
 
 void KThread::WaitCancel() {
@@ -722,22 +721,19 @@ void KThread::TrySuspend() {
     ASSERT(GetNumKernelWaiters() == 0);
 
     // Perform the suspend.
-    this->UpdateState();
+    Suspend();
 }
 
-void KThread::UpdateState() {
+void KThread::Suspend() {
     ASSERT(kernel.GlobalSchedulerContext().IsLocked());
+    ASSERT(IsSuspendRequested());
 
     // Set our suspend flags in state.
     const auto old_state = thread_state;
-    const auto new_state =
-        static_cast<ThreadState>(this->GetSuspendFlags()) | (old_state & ThreadState::Mask);
-    thread_state = new_state;
+    thread_state = static_cast<ThreadState>(GetSuspendFlags()) | (old_state & ThreadState::Mask);
 
     // Note the state change in scheduler.
-    if (new_state != old_state) {
-        KScheduler::OnThreadStateChanged(kernel, this, old_state);
-    }
+    KScheduler::OnThreadStateChanged(kernel, this, old_state);
 }
 
 void KThread::Continue() {
@@ -1002,16 +998,13 @@ ResultCode KThread::Run() {
 
         // If the current thread has been asked to suspend, suspend it and retry.
         if (GetCurrentThread(kernel).IsSuspended()) {
-            GetCurrentThread(kernel).UpdateState();
+            GetCurrentThread(kernel).Suspend();
             continue;
         }
 
         // If we're not a kernel thread and we've been asked to suspend, suspend ourselves.
-        if (KProcess* owner = this->GetOwnerProcess(); owner != nullptr) {
-            if (IsUserThread() && IsSuspended()) {
-                this->UpdateState();
-            }
-            owner->IncrementThreadCount();
+        if (IsUserThread() && IsSuspended()) {
+            Suspend();
         }
 
         // Set our state and finish.
@@ -1036,18 +1029,11 @@ void KThread::Exit() {
     {
         KScopedSchedulerLock sl{kernel};
 
-        // Disallow all suspension.
-        suspend_allowed_flags = 0;
-        this->UpdateState();
-
         // Disallow all suspension.
         suspend_allowed_flags = 0;
 
         // Start termination.
         StartTermination();
-
-        // Register the thread as a work task.
-        KWorkerTaskManager::AddTask(kernel, KWorkerTaskManager::WorkerType::Exit, this);
     }
 }
 

src/core/hle/kernel/k_thread.h

@@ -19,7 +19,6 @@
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_spin_lock.h"
 #include "core/hle/kernel/k_synchronization_object.h"
-#include "core/hle/kernel/k_worker_task.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_common.h"
 #include "core/hle/kernel/svc_types.h"
@@ -101,7 +100,7 @@ enum class ThreadWaitReasonForDebugging : u32 {
 [[nodiscard]] KThread& GetCurrentThread(KernelCore& kernel);
 [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel);
 
-class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
+class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KSynchronizationObject>,
                       public boost::intrusive::list_base_hook<> {
     KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject);
 
@@ -193,10 +192,10 @@ public:
 
     void TrySuspend();
 
-    void UpdateState();
-
     void Continue();
 
+    void Suspend();
+
     constexpr void SetSyncedIndex(s32 index) {
         synced_index = index;
     }
@@ -386,8 +385,6 @@ public:
 
     void OnTimer();
 
-    void DoWorkerTaskImpl();
-
     static void PostDestroy(uintptr_t arg);
 
     [[nodiscard]] static ResultCode InitializeDummyThread(KThread* thread);
@@ -682,8 +679,6 @@ private:
 
     void StartTermination();
 
-    void FinishTermination();
-
     [[nodiscard]] ResultCode Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top,
                                         s32 prio, s32 virt_core, KProcess* owner, ThreadType type);
 

src/core/hle/kernel/k_worker_task.h

@@ -1,18 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/k_synchronization_object.h"
-
-namespace Kernel {
-
-class KWorkerTask : public KSynchronizationObject {
-public:
-    explicit KWorkerTask(KernelCore& kernel_);
-
-    void DoWorkerTask();
-};
-
-} // namespace Kernel

src/core/hle/kernel/k_worker_task_manager.cpp

@@ -1,42 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_worker_task.h"
-#include "core/hle/kernel/k_worker_task_manager.h"
-#include "core/hle/kernel/kernel.h"
-
-namespace Kernel {
-
-KWorkerTask::KWorkerTask(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
-
-void KWorkerTask::DoWorkerTask() {
-    if (auto* const thread = this->DynamicCast<KThread*>(); thread != nullptr) {
-        return thread->DoWorkerTaskImpl();
-    } else {
-        auto* const process = this->DynamicCast<KProcess*>();
-        ASSERT(process != nullptr);
-
-        return process->DoWorkerTaskImpl();
-    }
-}
-
-KWorkerTaskManager::KWorkerTaskManager() : m_waiting_thread(1, "yuzu:KWorkerTaskManager") {}
-
-void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task) {
-    ASSERT(type <= WorkerType::Count);
-    kernel.WorkerTaskManager().AddTask(kernel, task);
-}
-
-void KWorkerTaskManager::AddTask(KernelCore& kernel, KWorkerTask* task) {
-    KScopedSchedulerLock sl(kernel);
-    m_waiting_thread.QueueWork([task]() {
-        // Do the task.
-        task->DoWorkerTask();
-    });
-}
-
-} // namespace Kernel

src/core/hle/kernel/k_worker_task_manager.h

@@ -1,33 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "common/thread_worker.h"
-
-namespace Kernel {
-
-class KernelCore;
-class KWorkerTask;
-
-class KWorkerTaskManager final {
-public:
-    enum class WorkerType : u32 {
-        Exit,
-        Count,
-    };
-
-    KWorkerTaskManager();
-
-    static void AddTask(KernelCore& kernel_, WorkerType type, KWorkerTask* task);
-
-private:
-    void AddTask(KernelCore& kernel, KWorkerTask* task);
-
-private:
-    Common::ThreadWorker m_waiting_thread;
-};
-
-} // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -37,7 +37,6 @@
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_slab_heap.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_worker_task_manager.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/service_thread.h"
@@ -798,8 +797,6 @@ struct KernelCore::Impl {
 
     std::array<u64, Core::Hardware::NUM_CPU_CORES> svc_ticks{};
 
-    KWorkerTaskManager worker_task_manager;
-
     // System context
     Core::System& system;
 };
@@ -1140,14 +1137,6 @@ const Init::KSlabResourceCounts& KernelCore::SlabResourceCounts() const {
     return impl->slab_resource_counts;
 }
 
-KWorkerTaskManager& KernelCore::WorkerTaskManager() {
-    return impl->worker_task_manager;
-}
-
-const KWorkerTaskManager& KernelCore::WorkerTaskManager() const {
-    return impl->worker_task_manager;
-}
-
 bool KernelCore::IsPhantomModeForSingleCore() const {
     return impl->IsPhantomModeForSingleCore();
 }

src/core/hle/kernel/kernel.h

@@ -52,7 +52,6 @@ class KSharedMemory;
 class KSharedMemoryInfo;
 class KThread;
 class KTransferMemory;
-class KWorkerTaskManager;
 class KWritableEvent;
 class KCodeMemory;
 class PhysicalCore;
@@ -344,12 +343,6 @@ public:
     /// Gets the current slab resource counts.
     const Init::KSlabResourceCounts& SlabResourceCounts() const;
 
-    /// Gets the current worker task manager, used for dispatching KThread/KProcess tasks.
-    KWorkerTaskManager& WorkerTaskManager();
-
-    /// Gets the current worker task manager, used for dispatching KThread/KProcess tasks.
-    const KWorkerTaskManager& WorkerTaskManager() const;
-
 private:
     friend class KProcess;
     friend class KThread;

src/core/hle/service/hid/hid.cpp

@@ -1176,8 +1176,7 @@ void Hid::SetNpadAnalogStickUseCenterClamp(Kernel::HLERequestContext& ctx) {
 
     const auto parameters{rp.PopRaw<Parameters>()};
 
-    GetAppletResource()
-        ->GetController<Controller_NPad>(HidController::NPad)
+    applet_resource->GetController<Controller_NPad>(HidController::NPad)
         .SetAnalogStickUseCenterClamp(parameters.analog_stick_use_center_clamp);
 
     LOG_WARNING(Service_HID,

src/input_common/drivers/mouse.cpp

@@ -16,7 +16,6 @@ constexpr int mouse_axis_x = 0;
 constexpr int mouse_axis_y = 1;
 constexpr int wheel_axis_x = 2;
 constexpr int wheel_axis_y = 3;
-constexpr int motion_wheel_y = 4;
 constexpr int touch_axis_x = 10;
 constexpr int touch_axis_y = 11;
 constexpr PadIdentifier identifier = {
@@ -31,9 +30,8 @@ Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_))
     PreSetAxis(identifier, mouse_axis_y);
     PreSetAxis(identifier, wheel_axis_x);
     PreSetAxis(identifier, wheel_axis_y);
-    PreSetAxis(identifier, motion_wheel_y);
     PreSetAxis(identifier, touch_axis_x);
-    PreSetAxis(identifier, touch_axis_y);
+    PreSetAxis(identifier, touch_axis_x);
     update_thread = std::jthread([this](std::stop_token stop_token) { UpdateThread(stop_token); });
 }
 
@@ -50,8 +48,6 @@ void Mouse::UpdateThread(std::stop_token stop_token) {
             SetAxis(identifier, mouse_axis_y, -last_mouse_change.y * sensitivity);
         }
 
-        SetAxis(identifier, motion_wheel_y, 0.0f);
-
         if (mouse_panning_timout++ > 20) {
             StopPanning();
         }
@@ -140,7 +136,6 @@ void Mouse::MouseWheelChange(int x, int y) {
     wheel_position.y += y;
     SetAxis(identifier, wheel_axis_x, static_cast<f32>(wheel_position.x));
     SetAxis(identifier, wheel_axis_y, static_cast<f32>(wheel_position.y));
-    SetAxis(identifier, motion_wheel_y, static_cast<f32>(y) / 100.0f);
 }
 
 void Mouse::ReleaseAllButtons() {
@@ -176,39 +171,13 @@ AnalogMapping Mouse::GetAnalogMappingForDevice(
     return mapping;
 }
 
-Common::Input::ButtonNames Mouse::GetUIButtonName(const Common::ParamPackage& params) const {
-    const auto button = static_cast<MouseButton>(params.Get("button", 0));
-    switch (button) {
-    case MouseButton::Left:
-        return Common::Input::ButtonNames::ButtonLeft;
-    case MouseButton::Right:
-        return Common::Input::ButtonNames::ButtonRight;
-    case MouseButton::Wheel:
-        return Common::Input::ButtonNames::ButtonMouseWheel;
-    case MouseButton::Backward:
-        return Common::Input::ButtonNames::ButtonBackward;
-    case MouseButton::Forward:
-        return Common::Input::ButtonNames::ButtonForward;
-    case MouseButton::Task:
-        return Common::Input::ButtonNames::ButtonTask;
-    case MouseButton::Extra:
-        return Common::Input::ButtonNames::ButtonExtra;
-    case MouseButton::Undefined:
-    default:
-        return Common::Input::ButtonNames::Undefined;
-    }
-}
-
 Common::Input::ButtonNames Mouse::GetUIName(const Common::ParamPackage& params) const {
     if (params.Has("button")) {
-        return GetUIButtonName(params);
+        return Common::Input::ButtonNames::Value;
     }
     if (params.Has("axis")) {
         return Common::Input::ButtonNames::Value;
     }
-    if (params.Has("axis_x") && params.Has("axis_y") && params.Has("axis_z")) {
-        return Common::Input::ButtonNames::Engine;
-    }
 
     return Common::Input::ButtonNames::Invalid;
 }

src/input_common/drivers/mouse.h

@@ -69,8 +69,6 @@ private:
     void UpdateThread(std::stop_token stop_token);
     void StopPanning();
 
-    Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
-
     Common::Vec2<int> mouse_origin;
     Common::Vec2<int> last_mouse_position;
     Common::Vec2<float> last_mouse_change;

src/input_common/input_engine.cpp

@@ -173,7 +173,7 @@ void InputEngine::ResetButtonState() {
             SetButton(controller.first, button.first, false);
         }
         for (const auto& button : controller.second.hat_buttons) {
-            SetHatButton(controller.first, button.first, 0);
+            SetHatButton(controller.first, button.first, false);
         }
     }
 }

src/input_common/input_mapping.cpp

@@ -143,19 +143,6 @@ void MappingFactory::RegisterMotion(const MappingData& data) {
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
     new_input.Set("pad", static_cast<int>(data.pad.pad));
-
-    // If engine is mouse map the mouse position as 3 axis motion
-    if (data.engine == "mouse") {
-        new_input.Set("axis_x", 1);
-        new_input.Set("invert_x", "-");
-        new_input.Set("axis_y", 0);
-        new_input.Set("axis_z", 4);
-        new_input.Set("range", 1.0f);
-        new_input.Set("deadzone", 0.0f);
-        input_queue.Push(new_input);
-        return;
-    }
-
     switch (data.type) {
     case EngineInputType::Button:
     case EngineInputType::HatButton:

src/video_core/host_shaders/astc_decoder.comp

@@ -155,6 +155,9 @@ uint SwizzleOffset(uvec2 pos) {
 // Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)]
 // is the same as [(num_bits - 1):0] and repeats all the way down.
 uint Replicate(uint val, uint num_bits, uint to_bit) {
+    if (num_bits == 0 || to_bit == 0) {
+        return 0;
+    }
     const uint v = val & uint((1 << num_bits) - 1);
     uint res = v;
     uint reslen = num_bits;
@@ -184,57 +187,42 @@ uint ReplicateBitTo9(uint value) {
     return REPLICATE_1_BIT_TO_9_TABLE[value];
 }
 
-uint FastReplicate(uint value, uint num_bits, uint to_bit) {
-    if (num_bits == 0) {
-        return 0;
-    }
-    if (num_bits == to_bit) {
+uint FastReplicateTo8(uint value, uint num_bits) {
+    switch (num_bits) {
+    case 1:
+        return REPLICATE_1_BIT_TO_8_TABLE[value];
+    case 2:
+        return REPLICATE_2_BIT_TO_8_TABLE[value];
+    case 3:
+        return REPLICATE_3_BIT_TO_8_TABLE[value];
+    case 4:
+        return REPLICATE_4_BIT_TO_8_TABLE[value];
+    case 5:
+        return REPLICATE_5_BIT_TO_8_TABLE[value];
+    case 6:
+        return REPLICATE_6_BIT_TO_8_TABLE[value];
+    case 7:
+        return REPLICATE_7_BIT_TO_8_TABLE[value];
+    case 8:
         return value;
     }
-    if (to_bit == 6) {
-        switch (num_bits) {
-        case 1:
-            return REPLICATE_1_BIT_TO_6_TABLE[value];
-        case 2:
-            return REPLICATE_2_BIT_TO_6_TABLE[value];
-        case 3:
-            return REPLICATE_3_BIT_TO_6_TABLE[value];
-        case 4:
-            return REPLICATE_4_BIT_TO_6_TABLE[value];
-        case 5:
-            return REPLICATE_5_BIT_TO_6_TABLE[value];
-        default:
-            break;
-        }
-    } else { /* if (to_bit == 8) */
-        switch (num_bits) {
-        case 1:
-            return REPLICATE_1_BIT_TO_8_TABLE[value];
-        case 2:
-            return REPLICATE_2_BIT_TO_8_TABLE[value];
-        case 3:
-            return REPLICATE_3_BIT_TO_8_TABLE[value];
-        case 4:
-            return REPLICATE_4_BIT_TO_8_TABLE[value];
-        case 5:
-            return REPLICATE_5_BIT_TO_8_TABLE[value];
-        case 6:
-            return REPLICATE_6_BIT_TO_8_TABLE[value];
-        case 7:
-            return REPLICATE_7_BIT_TO_8_TABLE[value];
-        default:
-            break;
-        }
-    }
-    return Replicate(value, num_bits, to_bit);
-}
-
-uint FastReplicateTo8(uint value, uint num_bits) {
-    return FastReplicate(value, num_bits, 8);
+    return Replicate(value, num_bits, 8);
 }
 
 uint FastReplicateTo6(uint value, uint num_bits) {
-    return FastReplicate(value, num_bits, 6);
+    switch (num_bits) {
+    case 1:
+        return REPLICATE_1_BIT_TO_6_TABLE[value];
+    case 2:
+        return REPLICATE_2_BIT_TO_6_TABLE[value];
+    case 3:
+        return REPLICATE_3_BIT_TO_6_TABLE[value];
+    case 4:
+        return REPLICATE_4_BIT_TO_6_TABLE[value];
+    case 5:
+        return REPLICATE_5_BIT_TO_6_TABLE[value];
+    }
+    return Replicate(value, num_bits, 6);
 }
 
 uint Div3Floor(uint v) {

src/yuzu/configuration/config.cpp

@@ -65,18 +65,18 @@ const std::array<int, 2> Config::default_stick_mod = {
 // This must be in alphabetical order according to action name as it must have the same order as
 // UISetting::values.shortcuts, which is alphabetically ordered.
 // clang-format off
-const std::array<UISettings::Shortcut, 21> Config::default_hotkeys{{
+const std::array<UISettings::Shortcut, 20> Config::default_hotkeys{{
+    {QStringLiteral("Audio Mute/Unmute"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"),  QStringLiteral("Home+Dpad_Right"), Qt::WindowShortcut}},
+    {QStringLiteral("Audio Volume Down"),        QStringLiteral("Main Window"), {QStringLiteral("-"),       QStringLiteral("Home+Dpad_Down"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Audio Volume Up"),          QStringLiteral("Main Window"), {QStringLiteral("+"),       QStringLiteral("Home+Dpad_Up"), Qt::ApplicationShortcut}},
     {QStringLiteral("Capture Screenshot"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"),  QStringLiteral("Screenshot"), Qt::WidgetWithChildrenShortcut}},
     {QStringLiteral("Change Docked Mode"),       QStringLiteral("Main Window"), {QStringLiteral("F10"),     QStringLiteral("Home+X"), Qt::ApplicationShortcut}},
     {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"),      QStringLiteral("Home+Plus"), Qt::WindowShortcut}},
-    {QStringLiteral("Decrease Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("-"),       QStringLiteral(""), Qt::ApplicationShortcut}},
     {QStringLiteral("Exit Fullscreen"),          QStringLiteral("Main Window"), {QStringLiteral("Esc"),     QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Exit yuzu"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"),  QStringLiteral("Home+Minus"), Qt::WindowShortcut}},
     {QStringLiteral("Fullscreen"),               QStringLiteral("Main Window"), {QStringLiteral("F11"),     QStringLiteral("Home+B"), Qt::WindowShortcut}},
-    {QStringLiteral("Increase Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("+"),       QStringLiteral(""), Qt::ApplicationShortcut}},
     {QStringLiteral("Load Amiibo"),              QStringLiteral("Main Window"), {QStringLiteral("F2"),      QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut}},
     {QStringLiteral("Load File"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"),  QStringLiteral(""), Qt::WidgetWithChildrenShortcut}},
-    {QStringLiteral("Mute Audio"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"),  QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"),      QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Stop Emulation"),           QStringLiteral("Main Window"), {QStringLiteral("F5"),      QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("TAS Start/Stop"),           QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), QStringLiteral(""), Qt::ApplicationShortcut}},
@@ -85,7 +85,6 @@ const std::array<UISettings::Shortcut, 21> Config::default_hotkeys{{
     {QStringLiteral("Toggle Filter Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"),  QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Toggle Framerate Limit"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"),  QStringLiteral("Home+Y"), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Mouse Panning"),     QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Toggle Speed Limit"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"),  QStringLiteral(""), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Status Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"),  QStringLiteral(""), Qt::WindowShortcut}},
 }};
 // clang-format on
@@ -743,10 +742,7 @@ void Config::ReadUIValues() {
     qt_config->beginGroup(QStringLiteral("UI"));
 
     UISettings::values.theme =
-        ReadSetting(
-            QStringLiteral("theme"),
-            QString::fromUtf8(
-                UISettings::themes[static_cast<size_t>(UISettings::Theme::DarkColorful)].second))
+        ReadSetting(QStringLiteral("theme"), QString::fromUtf8(UISettings::themes[0].second))
             .toString();
     ReadBasicSetting(UISettings::values.enable_discord_presence);
     ReadBasicSetting(UISettings::values.select_user_on_boot);
@@ -1273,10 +1269,8 @@ void Config::SaveSystemValues() {
 void Config::SaveUIValues() {
     qt_config->beginGroup(QStringLiteral("UI"));
 
-    WriteSetting(
-        QStringLiteral("theme"), UISettings::values.theme,
-        QString::fromUtf8(
-            UISettings::themes[static_cast<size_t>(UISettings::Theme::DarkColorful)].second));
+    WriteSetting(QStringLiteral("theme"), UISettings::values.theme,
+                 QString::fromUtf8(UISettings::themes[0].second));
     WriteBasicSetting(UISettings::values.enable_discord_presence);
     WriteBasicSetting(UISettings::values.select_user_on_boot);
 

src/yuzu/configuration/config.h

@@ -46,7 +46,7 @@ public:
         default_mouse_buttons;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> default_keyboard_keys;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> default_keyboard_mods;
-    static const std::array<UISettings::Shortcut, 21> default_hotkeys;
+    static const std::array<UISettings::Shortcut, 20> default_hotkeys;
 
 private:
     void Initialize(const std::string& config_name);

src/yuzu/configuration/configure_input_player.cpp

@@ -102,16 +102,6 @@ QString GetButtonName(Common::Input::ButtonNames button_name) {
         return QObject::tr("Share");
     case Common::Input::ButtonNames::Options:
         return QObject::tr("Options");
-    case Common::Input::ButtonNames::ButtonMouseWheel:
-        return QObject::tr("Wheel", "Indicates the mouse wheel");
-    case Common::Input::ButtonNames::ButtonBackward:
-        return QObject::tr("Backward");
-    case Common::Input::ButtonNames::ButtonForward:
-        return QObject::tr("Forward");
-    case Common::Input::ButtonNames::ButtonTask:
-        return QObject::tr("Task");
-    case Common::Input::ButtonNames::ButtonExtra:
-        return QObject::tr("Extra");
     default:
         return QObject::tr("[undefined]");
     }

src/yuzu/main.cpp

@@ -1008,33 +1008,24 @@ void GMainWindow::InitializeHotkeys() {
             ToggleFullscreen();
         }
     });
-    connect_shortcut(QStringLiteral("Toggle Speed Limit"), [&] {
-        Settings::values.use_speed_limit.SetValue(!Settings::values.use_speed_limit.GetValue());
-        UpdateStatusBar();
-    });
-    constexpr u16 SPEED_LIMIT_STEP = 5;
-    connect_shortcut(QStringLiteral("Increase Speed Limit"), [&] {
-        if (Settings::values.speed_limit.GetValue() < 9999 - SPEED_LIMIT_STEP) {
-            Settings::values.speed_limit.SetValue(SPEED_LIMIT_STEP +
-                                                  Settings::values.speed_limit.GetValue());
-            UpdateStatusBar();
-        }
-    });
-    connect_shortcut(QStringLiteral("Decrease Speed Limit"), [&] {
-        if (Settings::values.speed_limit.GetValue() > SPEED_LIMIT_STEP) {
-            Settings::values.speed_limit.SetValue(Settings::values.speed_limit.GetValue() -
-                                                  SPEED_LIMIT_STEP);
-            UpdateStatusBar();
-        }
-    });
     connect_shortcut(QStringLiteral("Change Docked Mode"), [&] {
         Settings::values.use_docked_mode.SetValue(!Settings::values.use_docked_mode.GetValue());
         OnDockedModeChanged(!Settings::values.use_docked_mode.GetValue(),
                             Settings::values.use_docked_mode.GetValue(), *system);
         dock_status_button->setChecked(Settings::values.use_docked_mode.GetValue());
     });
-    connect_shortcut(QStringLiteral("Mute Audio"),
+    connect_shortcut(QStringLiteral("Audio Mute/Unmute"),
                      [] { Settings::values.audio_muted = !Settings::values.audio_muted; });
+    connect_shortcut(QStringLiteral("Audio Volume Down"), [] {
+        const auto current_volume = static_cast<int>(Settings::values.volume.GetValue());
+        const auto new_volume = std::max(current_volume - 5, 0);
+        Settings::values.volume.SetValue(static_cast<u8>(new_volume));
+    });
+    connect_shortcut(QStringLiteral("Audio Volume Up"), [] {
+        const auto current_volume = static_cast<int>(Settings::values.volume.GetValue());
+        const auto new_volume = std::min(current_volume + 5, 100);
+        Settings::values.volume.SetValue(static_cast<u8>(new_volume));
+    });
     connect_shortcut(QStringLiteral("Toggle Framerate Limit"), [] {
         Settings::values.disable_fps_limit.SetValue(!Settings::values.disable_fps_limit.GetValue());
     });

src/yuzu/uisettings.h

@@ -29,15 +29,6 @@ struct Shortcut {
     ContextualShortcut shortcut;
 };
 
-enum class Theme {
-    Default,
-    DefaultColorful,
-    Dark,
-    DarkColorful,
-    MidnightBlue,
-    MidnightBlueColorful,
-};
-
 using Themes = std::array<std::pair<const char*, const char*>, 6>;
 extern const Themes themes;