blob: 1291e9e0ef98d3cf0e6a312903686a8ece860d92 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <list>
#include <memory>
#include <mutex>
#include <optional>
#include <thread>
#include "audio_core/renderer/system.h"
namespace Core {
namespace Timing {
struct EventType;
}
class System;
} // namespace Core
namespace AudioCore::AudioRenderer {
namespace ADSP {
class ADSP;
class AudioRenderer_Mailbox;
} // namespace ADSP
/**
* Manages all audio renderers, responsible for triggering command list generation and signalling
* the ADSP.
*/
class SystemManager {
public:
explicit SystemManager(Core::System& core);
~SystemManager();
/**
* Initialize the system manager, called when any system is registered.
*
* @return True if sucessfully initialized, otherwise false.
*/
bool InitializeUnsafe();
/**
* Stop the system manager.
*/
void Stop();
/**
* Add an audio render system to the manager.
* The manager does not own the system, so do not free it without calling Remove.
*
* @param system - The system to add.
* @return True if succesfully added, otherwise false.
*/
bool Add(System& system);
/**
* Remove an audio render system from the manager.
*
* @param system - The system to remove.
* @return True if succesfully removed, otherwise false.
*/
bool Remove(System& system);
private:
/**
* Main thread responsible for command generation.
*/
void ThreadFunc();
/**
* Signalling core timing thread to run ThreadFunc.
*/
std::optional<std::chrono::nanoseconds> ThreadFunc2(s64 time);
/**
* Callback from core timing when pausing, used to detect shutdowns and stop ThreadFunc.
*
* @param paused - Are we pausing or resuming?
*/
void PauseCallback(bool paused);
enum class StreamState {
Filling,
Steady,
Draining,
};
/// Core system
Core::System& core;
/// List of pointers to managed systems
std::list<System*> systems{};
/// Main worker thread for generating command lists
std::jthread thread;
/// Mutex for the systems
std::mutex mutex1{};
/// Mutex for adding/removing systems
std::mutex mutex2{};
/// Is the system manager thread active?
std::atomic<bool> active{};
/// Reference to the ADSP for communication
ADSP::ADSP& adsp;
/// AudioRenderer mailbox for communication
ADSP::AudioRenderer_Mailbox* mailbox{};
/// Core timing event to signal main thread
std::shared_ptr<Core::Timing::EventType> thread_event;
/// Atomic for main thread to wait on
std::atomic<bool> update{};
/// Current state of the streams
StreamState state{StreamState::Filling};
};
} // namespace AudioCore::AudioRenderer
|
