2#include <Process/Dataflow/Port.hpp>
3#include <Process/ExecutionContext.hpp>
4#include <Process/ExecutionSetup.hpp>
5#include <Process/ExecutionTransaction.hpp>
6#include <Process/Process.hpp>
8#include <Curve/CurveConversion.hpp>
10#include <Scenario/Document/Interval/IntervalModel.hpp>
11#include <Scenario/Document/ScenarioDocument/ScenarioDocumentModel.hpp>
12#include <Scenario/Document/Tempo/TempoProcess.hpp>
14#include <ossia/dataflow/graph/graph_interface.hpp>
15#include <ossia/dataflow/graph_edge.hpp>
16#include <ossia/dataflow/graph_node.hpp>
17#include <ossia/dataflow/port.hpp>
18#include <ossia/detail/pod_vector.hpp>
19#include <ossia/editor/curve/curve.hpp>
20#include <ossia/editor/scenario/time_interval.hpp>
21#include <ossia/editor/scenario/time_process.hpp>
26inline std::pair<std::optional<ossia::tempo_curve>, Scenario::TempoProcess*>
29 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
31 if(
auto proc = itv.tempoCurve())
33 auto& curve = proc->curve();
35 const auto defaultdur = itv.duration.defaultDuration().msec();
36 auto scale_x = [&ctx, defaultdur](
double val) -> int64_t {
37 return ctx.
time(TimeVal::fromMsecs(val * defaultdur)).impl;
39 auto scale_y = [=](
double val) ->
double {
41 return val * (TempoProcess::max - TempoProcess::min) + TempoProcess::min;
46 auto segt_data = curve.sortedSegments();
47 if(segt_data.size() != 0)
49 t = std::move(*Engine::score_to_ossia::curve<int64_t, double>(
50 scale_x, scale_y, segt_data, {}));
53 return {std::optional<ossia::tempo_curve>{std::move(t)}, proc};
60inline ossia::time_signature_map
63 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
64 ossia::time_signature_map ret;
65 for(
const auto& [time, sig] : itv.timeSignatureMap())
67 ret[ctx.
time(time)] = sig;
74 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
75 ossia::pod_vector<std::size_t> propagated_outlets;
76 for(std::size_t i = 0; i < outlets.size(); i++)
78 if(
auto o = qobject_cast<Process::AudioOutlet*>(outlets[i]))
80 propagated_outlets.push_back(i);
82 return propagated_outlets;
85inline void connectPropagated(
86 const ossia::node_ptr& process_node,
const ossia::node_ptr& interval_node,
87 ossia::graph_interface& g,
88 const ossia::pod_vector<std::size_t>& propagated_outlets)
noexcept
90 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Audio);
91 const auto& outs = process_node->root_outputs();
92 for(std::size_t propagated : propagated_outlets)
94 if(propagated >= outs.size())
97 if(outs[propagated]->which() == ossia::audio_port::which)
99 auto cable = g.allocate_edge(
100 ossia::immediate_glutton_connection{}, outs[propagated],
101 interval_node->root_inputs()[0], process_node, interval_node);
107inline void updatePropagated(
108 const ossia::node_ptr& process_node,
const ossia::node_ptr& interval_node,
109 ossia::graph_interface& g, std::size_t port_idx,
bool is_propagated)
noexcept
111 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Audio);
112 const auto& outs = process_node->root_outputs();
114 if(port_idx >= outs.size())
117 const ossia::outlet& outlet = *outs[port_idx];
119 if(!outlet.target<ossia::audio_port>())
125 for(
const ossia::graph_edge* edge : outlet.targets)
127 if(edge->in_node == interval_node)
131 auto cable = g.allocate_edge(
132 ossia::immediate_glutton_connection{}, outs[port_idx],
133 interval_node->root_inputs()[0], process_node, interval_node);
138 for(ossia::graph_edge* edge : outlet.targets)
140 if(edge->in_node == interval_node)
152 std::shared_ptr<ossia::time_interval> cst;
153 ossia::time_interval* cst_ptr{};
154 std::weak_ptr<ossia::time_process> oproc_weak;
155 std::weak_ptr<ossia::graph_interface> g_weak;
156 ossia::pod_vector<std::size_t> propagated_outlets;
158 void operator()()
const noexcept
160 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Audio);
161 auto oproc = oproc_weak.lock();
165 auto g = g_weak.lock();
169 cst_ptr->add_time_process(oproc);
173 connectPropagated(oproc->node, cst_ptr->node, *g, propagated_outlets);
181 std::weak_ptr<ossia::graph_node> cst_node_weak;
182 std::weak_ptr<ossia::time_process> oproc_weak;
183 std::weak_ptr<ossia::graph_interface> g_weak;
186 void operator()(
bool propagate)
const noexcept
188 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
192 = std::distance(proc.outlets().begin(), ossia::find(proc.outlets(), outlet));
195 [cst_node_weak = this->cst_node_weak, g_weak = this->g_weak,
196 oproc_weak = this->oproc_weak, port_index, propagate] {
197 const auto g = g_weak.lock();
201 const auto cst_node = cst_node_weak.lock();
205 const auto oproc = oproc_weak.lock();
209 const auto& proc_node = oproc->node;
213 updatePropagated(proc_node, cst_node, *g, port_index, propagate);
222 std::weak_ptr<ossia::graph_node> fw_node;
225 std::weak_ptr<ossia::time_process> oproc_weak;
227 std::weak_ptr<ossia::graph_interface> g_weak;
229 void operator()()
const noexcept
231 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
234 if(
auto o = qobject_cast<Process::AudioOutlet*>(outlet))
237 o, &Process::AudioOutlet::propagateChanged, &component,
nullptr);
239 o, &Process::AudioOutlet::propagateChanged, &component,
241 component.system(), proc, fw_node, oproc_weak, g_weak, outlet});
249 std::weak_ptr<ossia::graph_node> cst_node_weak;
250 std::weak_ptr<ossia::time_process> oproc_weak;
251 std::weak_ptr<ossia::graph_interface> g_weak;
255 const ossia::node_ptr& old_node,
const ossia::node_ptr& new_node,
258 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Ui);
260 commands->push_back([cst_node_weak = this->cst_node_weak, g_weak = this->g_weak,
261 propagated = propagatedOutlets(proc.outlets()), old_node,
263 OSSIA_ENSURE_CURRENT_THREAD(ossia::thread_type::Audio);
264 auto cst_node = cst_node_weak.lock();
267 auto g = g_weak.lock();
274 ossia::graph_node& n = *old_node;
275 for(auto& outlet : n.root_outputs())
277 auto targets = outlet->targets;
278 for(auto e : targets)
280 if(e->in_node.get() == cst_node.get())
291 connectPropagated(new_node, cst_node, *g, propagated);
The Process class.
Definition score-lib-process/Process/Process.hpp:61
Definition IntervalModel.hpp:50
Components used for the execution of a score.
Definition ProcessComponent.cpp:14
Main plug-in of score.
Definition score-plugin-dataflow/Dataflow/PortItem.hpp:13
Definition IntervalExecutionHelpers.hpp:150
Definition ExecutionContext.hpp:76
ExecutionCommandQueue & executionQueue
Definition ExecutionContext.hpp:122
Execution::time_function time
Definition ExecutionContext.hpp:118
Definition IntervalExecutionHelpers.hpp:248
Definition IntervalExecutionHelpers.hpp:178
Definition IntervalExecutionHelpers.hpp:220
Definition ExecutionTransaction.hpp:20
Definition PortForward.hpp:27