2026-09-23 09:25:56

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

src/audio_core/renderer/system.cpp

@@ -100,8 +100,9 @@ u64 System::GetWorkBufferSize(const AudioRendererParameterInternal& params) {
 }
 
 System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
-    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()},
+    : core{core_}
-      adsp_rendered_event{adsp_rendered_event_} {}
+    , adsp_rendered_event{adsp_rendered_event_}
+{}
 
 Result System::Initialize(const AudioRendererParameterInternal& params,
                           Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
@@ -406,7 +407,7 @@ void System::Finalize() {
         return;
     }
 
-    if (active) {
+    if (IsActive()) {
         Stop();
     }
 
@@ -433,14 +434,12 @@ void System::Start() {
     std::scoped_lock l{lock};
     frames_elapsed = 0;
     state = State::Started;
-    active = true;
 }
 
 void System::Stop() {
     {
         std::scoped_lock l{lock};
         state = State::Stopped;
-        active = false;
     }
 
     if (execution_mode == ExecutionMode::Auto) {
@@ -480,8 +479,7 @@ Result System::Update(std::span<const u8> input, std::span<u8> performance, std:
         return result;
     }
 
-    result = info_updater.UpdateEffects(effect_context, active, memory_pool_workbuffer,
+    result = info_updater.UpdateEffects(effect_context, IsActive(), memory_pool_workbuffer, memory_pool_count);
-                                        memory_pool_count);
     if (result.IsError()) {
         LOG_ERROR(Service_Audio, "Failed to update Effects!");
         return result;
@@ -582,16 +580,16 @@ u32 System::GetRenderingDevice() const {
 }
 
 bool System::IsActive() const {
-    return active;
+    return state == State::Started;
 }
 
 void System::SendCommandToDsp() {
     std::scoped_lock l{lock};
-
+    auto& audio_renderer = core.AudioCore().ADSP().AudioRenderer();
     if (initialized) {
-        if (active) {
+        if (IsActive()) {
             terminate_event.Reset();
-            const auto remaining_command_count{audio_renderer.GetRemainCommandCount(session_id)};
+            const auto remaining_command_count = audio_renderer.GetRemainCommandCount(session_id);
             u64 command_size{0};
 
             if (remaining_command_count) {
@@ -738,7 +736,7 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
     const auto end_time{core.CoreTiming().GetGlobalTimeNs().count()};
     total_ticks_elapsed += end_time - start_time;
     num_command_lists_generated++;
-    render_start_tick = audio_renderer.GetRenderingStartTick(session_id);
+    render_start_tick = core.AudioCore().ADSP().AudioRenderer().GetRenderingStartTick(session_id);
     frames_elapsed++;
 
     return command_buffer.size;

src/audio_core/renderer/system.h

@@ -219,12 +219,8 @@ public:
 private:
     /// Core system
     Core::System& core;
-    /// Reference to the ADSP's AudioRenderer for communication
-    ::AudioCore::ADSP::AudioRenderer::AudioRenderer& audio_renderer;
     /// Is this system initialized?
     bool initialized{};
-    /// Is this system currently active?
-    std::atomic<bool> active{};
     /// State of the system
     State state{State::Stopped};
     /// Sample rate for the system

src/audio_core/renderer/system_manager.cpp

@@ -16,22 +16,22 @@
 namespace AudioCore::Renderer {
 
 SystemManager::SystemManager(Core::System& core_)
-    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()} {}
+    : core{core_}
+{}
 
 SystemManager::~SystemManager() {
     Stop();
 }
 
 void SystemManager::InitializeUnsafe() {
-    if (!active) {
+    if (!thread.joinable()) {
-        active = true;
+        core.AudioCore().ADSP().AudioRenderer().Start();
-        audio_renderer.Start();
         thread = std::jthread([this](std::stop_token stop_token) {
             Common::SetCurrentThreadName("AudioRenderSystemManager");
-            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+            auto& audio_renderer = core.AudioCore().ADSP().AudioRenderer();
-            while (active && !stop_token.stop_requested()) {
+            while (!stop_token.stop_requested()) {
                 {
-                    std::scoped_lock l{mutex1};
+                    std::scoped_lock lk{mutex};
                     for (auto system : systems)
                         system->SendCommandToDsp();
                 }
@@ -43,39 +43,31 @@ void SystemManager::InitializeUnsafe() {
 }
 
 void SystemManager::Stop() {
-    if (active) {
+    if (thread.joinable()) {
-        active = false;
         thread.request_stop();
         thread.join();
-        audio_renderer.Stop();
+        core.AudioCore().ADSP().AudioRenderer().Stop();
     }
 }
 
 bool SystemManager::Add(System& system_) {
-    std::scoped_lock l2{mutex2};
+    std::scoped_lock lk{mutex};
     if (systems.size() + 1 > MaxRendererSessions) {
         LOG_ERROR(Service_Audio, "Maximum AudioRenderer Systems active, cannot add more!");
         return false;
     }
-    {
+    if (systems.empty())
-        std::scoped_lock l{mutex1};
+        InitializeUnsafe();
-        if (systems.empty())
-            InitializeUnsafe();
-    }
     systems.push_back(&system_);
     return true;
 }
 
 bool SystemManager::Remove(System& system_) {
-    std::scoped_lock l2{mutex2};
+    std::scoped_lock lk{mutex};
-    {
+    if (systems.remove(&system_) == 0) {
-        std::scoped_lock l{mutex1};
+        LOG_ERROR(Service_Audio, "Failed to remove a render system, it was not found in the list!");
-        if (systems.remove(&system_) == 0) {
+        return false;
-            LOG_ERROR(Service_Audio, "Failed to remove a render system, it was not found in the list!");
-            return false;
-        }
     }
-
     if (systems.empty())
         Stop();
     return true;

src/audio_core/renderer/system_manager.h

@@ -75,14 +75,8 @@ private:
     std::list<System*> systems{};
     /// Main worker thread for generating command lists
     std::jthread thread;
-    /// Mutex for the systems
+    /// Mutex for the systems list
-    std::mutex mutex1{};
+    std::mutex mutex{};
-    /// Mutex for adding/removing systems
-    std::mutex mutex2{};
-    /// Is the system manager thread active?
-    std::atomic<bool> active{};
-    /// Reference to the ADSP's AudioRenderer for communication
-    ::AudioCore::ADSP::AudioRenderer::AudioRenderer& audio_renderer;
 };
 
 } // namespace AudioCore::Renderer