MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
ModalDampingOperator.cpp
Go to the documentation of this file.
2
6
8
9bool ModalDampingOperator::valid(const Response& response) noexcept
10{
11 return std::isfinite(response.quiet_seconds) && response.quiet_seconds > 0.0
12 && std::isfinite(response.loud_seconds) && response.loud_seconds > 0.0
13 && std::isfinite(response.reference_rms) && response.reference_rms > 0.0
14 && std::isfinite(response.smoothing_seconds) && response.smoothing_seconds >= 0.0;
15}
16
17ModalDampingOperator::ModalDampingOperator(const std::shared_ptr<ModalNetwork>& network)
19 , m_network(network)
20{
21 if (!network) {
23 "ModalDampingOperator has no ModalNetwork");
24 return;
25 }
26
27 m_modes.reserve(network->get_node_count());
28 for (size_t index = 0; index < network->get_node_count(); ++index) {
29 const double decay = network->get_mode_decay_time(index).value_or(m_default_response.quiet_seconds);
30 const double initial = std::isfinite(decay) && decay > 0.0
31 ? decay
32 : m_default_response.quiet_seconds;
33
34 m_modes.push_back(ModeState {
35 .response = m_default_response,
36 .decay_seconds = initial });
37 }
38}
39
40void ModalDampingOperator::set_mode(size_t index, const ModalDampingControls& controls)
41{
44
45 if (index >= m_modes.size()) {
47 "ModalDampingOperator ignored mode {}, it has {} modes", index, m_modes.size());
48 return;
49 }
50
51 auto& mode = m_modes[index];
52 const auto field = [&](const Control& control, double Response::* member, std::string_view name) {
53 if (!control.has_value() || control.sourced()) {
54 return;
55 }
56
57 Response candidate = mode.response;
58 candidate.*member = control.value();
59 if (!valid(candidate)) {
61 "ModalDampingOperator ignored invalid value for {}", name);
62 return;
63 }
64 mode.response = candidate;
65 };
66
67 field(controls.quiet_seconds, &Response::quiet_seconds, "quiet_seconds");
68 field(controls.loud_seconds, &Response::loud_seconds, "loud_seconds");
69 field(controls.reference_rms, &Response::reference_rms, "reference_rms");
70 field(controls.smoothing_seconds, &Response::smoothing_seconds, "smoothing_seconds");
71}
72
73bool ModalDampingOperator::apply_field(double Response::* member, double value)
74{
75 Response candidate = m_default_response;
76 candidate.*member = value;
77 if (!valid(candidate)) {
78 return false;
79 }
80
81 m_default_response = candidate;
82 for (auto& mode : m_modes) {
83 mode.response.*member = value;
84 }
85 return true;
86}
87
89{
90 const auto field = [this](Control& control, double Response::* member, std::string_view name) {
91 const auto value = control.pending();
92 if (value && !apply_field(member, *value)) {
94 "ModalDampingOperator ignored invalid value for {}", name);
95 }
96 };
97
98 field(m_controls.quiet_seconds, &Response::quiet_seconds, "quiet_seconds");
99 field(m_controls.loud_seconds, &Response::loud_seconds, "loud_seconds");
100 field(m_controls.reference_rms, &Response::reference_rms, "reference_rms");
101 field(m_controls.smoothing_seconds, &Response::smoothing_seconds, "smoothing_seconds");
102}
103
105{
106 controls.quiet_seconds.observe(m_default_response.quiet_seconds);
107 controls.loud_seconds.observe(m_default_response.loud_seconds);
108 controls.reference_rms.observe(m_default_response.reference_rms);
109 controls.smoothing_seconds.observe(m_default_response.smoothing_seconds);
110}
111
113{
116
117 const auto network = m_network.lock();
118 if (!network || network->get_sample_rate() == 0 || frames <= 0.0F) {
119 return;
120 }
121
122 const double dt = static_cast<double>(frames) / network->get_sample_rate();
123 const size_t count = std::min(m_modes.size(), network->get_node_count());
124
125 for (size_t index = 0; index < count; ++index) {
126 const auto buffer = network->get_node_audio_buffer(index);
127 double sum_squares = 0.0;
128
129 if (buffer) {
130 for (const double sample : *buffer) {
131 if (std::isfinite(sample)) {
132 sum_squares += sample * sample;
133 }
134 }
135 }
136
137 const double rms = buffer && !buffer->empty()
138 ? std::sqrt(sum_squares / static_cast<double>(buffer->size()))
139 : 0.0;
140
141 auto& mode = m_modes[index];
142 const auto& response = mode.response;
143 const double amount = std::clamp(rms / response.reference_rms, 0.0, 1.0);
144 const double target = std::lerp(response.quiet_seconds, response.loud_seconds, amount);
145
146 mode.decay_seconds = Kinesis::damp(
147 mode.decay_seconds, target, response.smoothing_seconds, dt);
148 (void)network->set_mode_decay_time(index, mode.decay_seconds);
149 }
150}
151
152void ModalDampingOperator::set_parameter(std::string_view name, double value)
153{
154 if (!set_named_control(name, value)) {
156 "ModalDampingOperator ignored unknown parameter {}", name);
157 }
158}
159
160std::optional<double> ModalDampingOperator::query_state(std::string_view name) const
161{
162 if (const auto value = ControlStore::read_named(get(), name)) {
163 return value;
164 }
165 if (name == "mode_count") {
166 return static_cast<double>(m_modes.size());
167 }
168 return std::nullopt;
169}
170
171}
#define MF_WARN(comp, ctx,...)
static std::optional< double > read_named(const C &controls, std::string_view name)
bool has_value() const noexcept
True once a value was given.
double value() const noexcept
The value as a double.
std::optional< T > pending() noexcept
The value to apply now as type T, or nullopt when nothing is due.
Definition Control.hpp:94
void observe(T actual) noexcept
Shows the value the owner really has, unless a source is feeding it.
Definition Control.hpp:134
bool sourced() const noexcept
True when a node or a network feeds this control.
Definition Control.hpp:68
One named control of a network or operator: empty, a value, or a mapped source.
Definition Control.hpp:34
void process(float frames) override
Process for one batch cycle.
std::optional< double > query_state(std::string_view name) const override
The control of that name as the operator holds it, or "mode_count".
static bool valid(const Response &response) noexcept
bool apply_field(double Response::*member, double value)
void set_parameter(std::string_view name, double value) override
Sets the control of that name, so "loud_seconds" is the same as set({ .loud_seconds = ....
ModalDampingOperator(const std::shared_ptr< ModalNetwork > &network)
void read_controls(ModalDampingControls &controls) const
Fills the controls whose value the operator holds outside the struct.
void set_mode(size_t index, const ModalDampingControls &controls)
Change one mode's response from the numbers controls holds.
C & declare_controls()
Create the operator's controls struct and keep it alive.
void refresh_controls()
Read node sources into their controls.
bool set_named_control(std::string_view name, double value)
Sets the control called name, the way set() would.
Self::Controls get(this const Self &self)
The controls with the values the operator holds now.
@ Configuration
Configuration and parameter updates.
@ Nodes
DSP Generator and Filter Nodes, graph pipeline, node management.
T damp(T current, T target, T smoothing, T dt) noexcept
Exponential smoothing: move current toward target at rate smoothing over time step dt.
Definition Scalar.hpp:162
Controls of a ModalDampingOperator, each a number or a mapped node.