1 files changed, 48 insertions, 52 deletions

diff --git a/src/audio_core/audio_manager.cpp b/src/audio_core/audio_manager.cpp
index 10b56f2140..93142a53fb 100644
--- a/src/audio_core/audio_manager.cpp
+++ b/src/audio_core/audio_manager.cpp
@@ -1,81 +1,77 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "audio_core/audio_manager.h"
+#include "common/thread.h"
 #include "core/core.h"
 #include "core/hle/service/audio/errors.h"
 
 namespace AudioCore {
 
 AudioManager::AudioManager() {
-    thread = std::jthread([this]() { ThreadFunc(); });
+    thread = std::jthread([this](std::stop_token stop_token) {
+        Common::SetCurrentThreadName("AudioManager");
+        std::unique_lock l{events.GetAudioEventLock()};
+        events.ClearEvents();
+        while (!stop_token.stop_requested()) {
+            const auto timed_out{events.Wait(l, std::chrono::seconds(2))};
+            if (events.CheckAudioEventSet(Event::Type::Max)) {
+                break;
+            }
+            for (size_t i = 0; i < buffer_events.size(); i++) {
+                const auto event_type = Event::Type(i);
+                if (events.CheckAudioEventSet(event_type) || timed_out) {
+                    if (buffer_events[i]) {
+                        buffer_events[i]();
+                    }
+                }
+                events.SetAudioEvent(event_type, false);
+            }
+        }
+    });
 }
 
 void AudioManager::Shutdown() {
-    running = false;
     events.SetAudioEvent(Event::Type::Max, true);
-    thread.join();
+    if (thread.joinable()) {
+        thread.request_stop();
+        thread.join();
+    }
 }
 
 Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
-    if (!running) {
-        return Service::Audio::ResultOperationFailed;
-    }
-
-    std::scoped_lock l{lock};
-
-    const auto index{events.GetManagerIndex(Event::Type::AudioOutManager)};
-    if (buffer_events[index] == nullptr) {
-        buffer_events[index] = std::move(buffer_func);
-        needs_update = true;
-        events.SetAudioEvent(Event::Type::AudioOutManager, true);
+    if (thread.joinable()) {
+        std::scoped_lock l{lock};
+        const auto index{events.GetManagerIndex(Event::Type::AudioOutManager)};
+        if (buffer_events[index] == nullptr) {
+            buffer_events[index] = std::move(buffer_func);
+            needs_update = true;
+            events.SetAudioEvent(Event::Type::AudioOutManager, true);
+        }
+        return ResultSuccess;
     }
-    return ResultSuccess;
+    return Service::Audio::ResultOperationFailed;
 }
 
 Result AudioManager::SetInManager(BufferEventFunc buffer_func) {
-    if (!running) {
-        return Service::Audio::ResultOperationFailed;
-    }
-
-    std::scoped_lock l{lock};
-
-    const auto index{events.GetManagerIndex(Event::Type::AudioInManager)};
-    if (buffer_events[index] == nullptr) {
-        buffer_events[index] = std::move(buffer_func);
-        needs_update = true;
-        events.SetAudioEvent(Event::Type::AudioInManager, true);
+    if (thread.joinable()) {
+        std::scoped_lock l{lock};
+        const auto index{events.GetManagerIndex(Event::Type::AudioInManager)};
+        if (buffer_events[index] == nullptr) {
+            buffer_events[index] = std::move(buffer_func);
+            needs_update = true;
+            events.SetAudioEvent(Event::Type::AudioInManager, true);
+        }
+        return ResultSuccess;
     }
-    return ResultSuccess;
+    return Service::Audio::ResultOperationFailed;
 }
 
 void AudioManager::SetEvent(const Event::Type type, const bool signalled) {
     events.SetAudioEvent(type, signalled);
 }
 
-void AudioManager::ThreadFunc() {
-    std::unique_lock l{events.GetAudioEventLock()};
-    events.ClearEvents();
-    running = true;
-
-    while (running) {
-        const auto timed_out{events.Wait(l, std::chrono::seconds(2))};
-
-        if (events.CheckAudioEventSet(Event::Type::Max)) {
-            break;
-        }
-
-        for (size_t i = 0; i < buffer_events.size(); i++) {
-            const auto event_type = static_cast<Event::Type>(i);
-
-            if (events.CheckAudioEventSet(event_type) || timed_out) {
-                if (buffer_events[i]) {
-                    buffer_events[i]();
-                }
-            }
-            events.SetAudioEvent(event_type, false);
-        }
-    }
-}
-
 } // namespace AudioCore