2#include <AvndProcesses/Utils.hpp>
3#include <Process/Process.hpp>
5#include <Crousti/File.hpp>
6#include <Crousti/MessageBus.hpp>
7#include <Crousti/ProcessModel.hpp>
8#include <Crousti/SoundSet.hpp>
10#include <ossia/detail/flat_map.hpp>
12#include <avnd/binding/ossia/node.hpp>
22template <
typename Node>
25 using safe_node<Node>::safe_node;
30 run(
const ossia::token_request& tk, ossia::exec_state_facade st)
noexcept override
33 safe_node<Node>::run(tk, st);
46template <oscr::has_dynamic_ports T>
51 ossia::flat_map<Process::Inlet*, std::pair<int, QMetaObject::Connection>>
61 ||
requires { T::placeholders(); })
63 { t.value } -> std::convertible_to<std::string_view>;
68template <
typename Field>
71 if constexpr(
requires { Field::placeholders(); })
73 if(
auto str = v.target<std::string>(); str && !str->empty())
74 return ossia::value{avnd_tools::filter_filename(*str, ctx).toStdString()};
78 return resolvePathValue(v, ctx);
91 = !std::is_trivially_destructible_v<T> ||
sizeof(T) > 64;
108 const std::atomic<uint64_t>* written{};
113 return written && written->load(std::memory_order_relaxed) !=
number;
116inline thread_local processor_write_back control_written_by_processor{};
118template <
typename Node,
typename Field, std::
size_t NPred, std::
size_t NField>
121 using ExecNode = safe_node<Node>;
123 std::weak_ptr<ExecNode> weak_node;
131 static constexpr std::size_t control_index
132 = avnd::control_input_introspection<Node>::field_index_to_index(
133 avnd::field_index<NField>{});
135 void operator()(
const ossia::value& val)
137 using control_value_type = std::decay_t<
decltype(Field::value)>;
139 const auto echo = control_written_by_processor.
field == &field
140 ? control_written_by_processor
142 if(
auto node = weak_node.lock())
144 if constexpr(control_value_owns_memory<control_value_type>)
146 auto v = std::make_unique<control_value_type>();
147 node->from_ossia_value(field, val, *v, avnd::field_index<NField>{});
148 ctx.executionQueue.enqueue([weak_node = weak_node, gcq = ctx.weakGCQueue(),
149 v = std::move(v), echo]()
mutable {
150 if(auto n = weak_node.lock(); n && !echo.stale())
151 n->template control_updated_from_ui<control_value_type, control_index>(
153 free_on_main_thread(gcq, v);
158 control_value_type v;
159 node->from_ossia_value(field, val, v, avnd::field_index<NField>{});
160 ctx.executionQueue.enqueue([weak_node = weak_node, v = std::move(v), echo]()
mutable {
161 if(
auto n = weak_node.lock(); n && !echo.stale())
163 n->template control_updated_from_ui<control_value_type, control_index>(
175template <
typename Node,
typename Field, std::
size_t NPred, std::
size_t NField>
178 using ExecNode = safe_node<Node>;
180 std::weak_ptr<ExecNode> weak_node;
183 void operator()(
const ossia::value& val)
185 using control_type = avnd::dynamic_port_type<Field>;
186 using control_value_type = std::decay_t<
decltype(control_type::value)>;
188 if(
auto node = weak_node.lock())
195 control_type witness{};
196 if constexpr(control_value_owns_memory<control_value_type>)
198 auto v = std::make_unique<control_value_type>();
199 node->from_ossia_value(witness, val, *v, avnd::field_index<NField>{});
200 ctx.executionQueue.enqueue([weak_node = weak_node, port_index = port_index,
201 gcq = ctx.weakGCQueue(), v = std::move(v)]()
mutable {
202 if(auto n = weak_node.lock())
203 n->template control_updated_from_ui<control_value_type, NPred>(
204 std::move(*v), port_index);
205 free_on_main_thread(gcq, v);
210 control_value_type v;
211 node->from_ossia_value(witness, val, v, avnd::field_index<NField>{});
212 ctx.executionQueue.enqueue([weak_node = weak_node, port_index = port_index,
213 v = std::move(v)]()
mutable {
214 if(
auto n = weak_node.lock())
216 n->template control_updated_from_ui<control_value_type, NPred>(
217 std::move(v), port_index);
225template <
typename Node,
typename Field>
228 using ExecNode = safe_node<Node>;
233 const std::shared_ptr<ExecNode>& node_ptr;
236 void invoke_update(Field& param,
int k)
238 avnd::effect_container<Node>& eff = node_ptr->impl;
240 for(
auto state : eff.full_state())
242 if constexpr(avnd::dynamic_ports_port<Field>)
244 avnd::update_if_holding_value(state, param.ports[k]);
248 avnd::update_if_holding_value(state, param);
254template <
typename Node,
typename Field, std::
size_t N, std::
size_t NField>
257template <
typename Node,
typename Field, std::
size_t N, std::
size_t NField>
260 using ExecNode = safe_node<Node>;
266 if constexpr(avnd::dynamic_ports_port<Field>)
268 using port_type = avnd::dynamic_port_type<Field>;
269 if constexpr(avnd::parameter_port<port_type>)
271 if constexpr(!
requires { param.ports[0].value.reset(); })
273 this->node_ptr->from_ossia_value(
274 param, inlet->value(), param.ports[k].value, avnd::field_index<NField>{});
280 if constexpr(!
requires { param.value.reset(); })
282 this->node_ptr->from_ossia_value(
283 param, inlet->value(), param.value, avnd::field_index<NField>{});
300 if constexpr(
requires { param.update_controller; })
302 using function_type = std::remove_cvref_t<
decltype(param.update_controller)>;
304 = std::remove_cvref_t<typename function_argument<function_type>::type>;
305 static constexpr bool is_text = std::is_same_v<arg_type, std::string_view>;
306 using value_type = std::conditional_t<is_text, std::string, arg_type>;
308 std::size_t capacity = 0;
309 if constexpr(is_text)
312 if constexpr(
requires { Field::max_length(); })
313 capacity = Field::max_length();
317 using written_value = std::pair<value_type, uint64_t>;
318 auto box = std::make_shared<latest_value<written_value>>();
319 if constexpr(is_text)
320 box->for_each_slot([capacity](written_value& s) { s.first.reserve(capacity); });
321 auto written = std::make_shared<std::atomic<uint64_t>>(0);
324 const void* field = ¶m;
325 auto wake = [inlet = QPointer{inlet}, self = QPointer{&this->element},
326 qed_ptr = this->ctx.weakEditionQueue(), box, field, written] {
327 auto qed = qed_ptr.lock();
333 if(qed->try_enqueue([inlet, self, box, field, written] {
334 auto v = box->take();
335 if(!v || !self || !inlet)
337 const auto previous = std::exchange(
338 control_written_by_processor,
340 if constexpr(
requires { Field::controller_value(v->first); })
341 inlet->setValue(oscr::to_ossia_value(Field::controller_value(v->first)));
343 inlet->setValue(v->first);
344 control_written_by_processor = previous;
360 wakeups->add([box, wake] {
361 if(!box->unpark() || !box->request())
367 param.update_controller
368 = [box, capacity, wake, wakeups, written](arg_type value) {
369 auto& slot = box->back();
370 if constexpr(is_text)
371 slot.first.assign(value.substr(0, std::min(value.size(), capacity)));
373 slot.first = std::move(value);
374 slot.second = written->fetch_add(1, std::memory_order_relaxed) + 1;
379 if(!wake() && wakeups)
392 if constexpr(
requires { control_data.m_connectedControls; })
394 auto it = control_data.m_connectedControls.find(inlet);
395 if(it != control_data.m_connectedControls.end())
397 if constexpr(!avnd::dynamic_ports_port<Field>)
399 if(it->second.first == k)
401 QObject::disconnect(it->second.second);
402 control_data.m_connectedControls.erase(it);
407 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
408 QMetaObject::Connection connection;
409 if constexpr(avnd::dynamic_ports_port<Field>)
411 connection = QObject::connect(
412 inlet, &Process::ControlInlet::valueChanged, this->parent,
417 connection = QObject::connect(
418 inlet, &Process::ControlInlet::valueChanged, this->parent,
422 if constexpr(
requires { control_data.m_connectedControls; })
423 control_data.m_connectedControls.emplace(inlet, std::pair{k, connection});
432 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
433 if constexpr(avnd::dynamic_ports_port<Field>)
446 void connect_control_to_ui(
450 reconnect_control_to_ui(control_data, param, inlet, k);
451 this->update_controller(param, inlet);
455template <
typename Node, avnd::soundfile_port Field, std::
size_t N, std::
size_t NField>
459 using ExecNode = safe_node<Node>;
466 if(
auto hdl = loadSoundfile(inlet->value(), this->ctx.doc, this->ctx.execState))
467 this->node_ptr->soundfile_loaded(
468 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
471 void connect_control_to_ui(
476 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
477 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
479 inlet, &Process::ControlInlet::valueChanged, this->parent,
480 [&ctx = this->ctx, weak_node = std::move(weak_node),
481 weak_st = std::move(weak_st)](
const ossia::value& v) {
482 if(
auto n = weak_node.lock())
483 if(
auto st = weak_st.lock())
484 if(
auto file = loadSoundfile(v, ctx.doc, st))
486 ctx.executionQueue.enqueue([f = std::move(file), weak_node,
487 gcq = ctx.weakGCQueue()]() mutable {
489 if(auto n = weak_node.lock())
490 f = n->soundfile_loaded(
491 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
492 free_on_main_thread(gcq, f);
499template <
typename Node, avnd::m
idifile_port Field, std::
size_t N, std::
size_t NField>
500struct setup_control_for_exec<Node, Field, N, NField>
501 : setup_control_for_exec_base<Node, Field>
503 using ExecNode = safe_node<Node>;
504 using Model = ProcessModel<Node>;
511 if(
auto hdl = loadMidifile(inlet->value(), this->ctx.doc))
512 this->node_ptr->midifile_loaded(
513 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
516 void connect_control_to_ui(
521 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
522 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
524 inlet, &Process::ControlInlet::valueChanged, this->parent,
525 [inlet, &ctx = this->ctx,
526 weak_node = std::move(weak_node)](
const ossia::value& v) {
527 if(
auto n = weak_node.lock())
528 if(
auto file = loadMidifile(v, ctx.doc))
530 ctx.executionQueue.enqueue([f = std::move(file), weak_node,
531 gcq = ctx.weakGCQueue()]() mutable {
533 if(auto n = weak_node.lock())
534 f = n->midifile_loaded(
535 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
536 free_on_main_thread(gcq, f);
543template <
typename Node, avnd::raw_file_port Field, std::
size_t N, std::
size_t NField>
544struct setup_control_for_exec<
Node, Field, N, NField>
545 : setup_control_for_exec_base<Node, Field>
547 using ExecNode = safe_node<Node>;
548 using Model = ProcessModel<Node>;
550 static constexpr bool has_text =
requires {
decltype(Field::file)::text; };
551 static constexpr bool has_mmap =
requires {
decltype(Field::file)::mmap; };
558 if(
auto hdl = loadRawfile(inlet->value(), this->ctx.doc, has_text, has_mmap))
560 if constexpr(avnd::port_can_process<Field>)
564 auto func = executePortPreprocess<Field>(*hdl);
565 this->node_ptr->file_loaded(
566 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
568 func(this->node_ptr->impl.effect);
572 this->node_ptr->file_loaded(
573 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
578 void connect_control_to_ui(
583 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
584 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
586 inlet, &Process::ControlInlet::valueChanged, this->parent,
587 [inlet, &ctx = this->ctx, weak_node = std::move(weak_node)] {
588 if(
auto n = weak_node.lock())
589 if(
auto file = loadRawfile(inlet->value(), ctx.doc, has_text, has_mmap))
591 if constexpr(avnd::port_can_process<Field>)
593 auto func = executePortPreprocess<Field>(*file);
594 ctx.executionQueue.enqueue([f = std::move(file), weak_node,
595 gcq = ctx.weakGCQueue(),
596 ff = std::move(func)]() mutable {
598 if(auto n = weak_node.lock())
601 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
605 free_on_main_thread(gcq, f, ff);
610 ctx.executionQueue.enqueue([f = std::move(file), weak_node,
611 gcq = ctx.weakGCQueue()]() mutable {
613 if(auto n = weak_node.lock())
615 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
616 free_on_main_thread(gcq, f);
628template <
typename Node, folder_control_port Field, std::
size_t N, std::
size_t NField>
629struct setup_control_for_exec<
Node, Field, N, NField>
630 : setup_control_for_exec_base<Node, Field>
632 using ExecNode = safe_node<Node>;
633 using Model = ProcessModel<Node>;
637 if constexpr(!
requires { param.value.reset(); })
639 this->node_ptr->from_ossia_value(
640 param, resolveControlPath<Field>(inlet->value(), this->ctx.doc), param.value,
641 avnd::field_index<NField>{});
645 void connect_control_to_ui(
649 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
651 inlet, &Process::ControlInlet::valueChanged, this->parent,
652 [&ctx = this->ctx, weak_node = std::move(weak_node),
653 field = ¶m](
const ossia::value& val) {
656 con_unvalidated<Node, Field, N, NField>{ctx, weak_node, *field}(
657 resolveControlPath<Field>(val, ctx.doc));
668template <
typename Node, sound_set_control_port Field, std::
size_t N, std::
size_t NField>
669struct setup_control_for_exec<Node, Field, N, NField>
670 : setup_control_for_exec_base<Node, Field>
672 using ExecNode = safe_node<Node>;
676 this->node_ptr->from_ossia_value(
677 param, resolveControlPath<Field>(inlet->value(), this->ctx.doc), param.value,
678 avnd::field_index<NField>{});
681 void connect_control_to_ui(
685 auto& ctx = this->ctx;
686 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
688 SoundSetOptions opts;
690 opts.recursive = Field::recursive();
691 opts.decoding = Field::decoding();
692 opts.rate = int(ossia::exec_state_facade{ctx.execState.get()}.sampleRate());
696 auto publish = [&ctx, weak_node](
697 std::shared_ptr<SoundSetSnapshot> next,
698 SoundSetSnapshot* previous) {
699 ctx.executionQueue.enqueue(
700 [weak_node, next = std::move(next), previous]()
mutable {
701 if(
auto n = weak_node.lock())
702 for(
auto state : n->impl.full_state())
703 avnd::pfr::get<NField>(state.inputs).files = next->view();
705 previous->superseded.store(
true, std::memory_order_release);
710 auto dispose = [&ctx](std::vector<std::shared_ptr<SoundSetSnapshot>> snaps) {
711 ctx.executionQueue.enqueue([snaps = std::move(snaps)] {});
714 auto loader =
new SoundSetLoader{
715 std::move(opts), std::move(publish), std::move(dispose), this->parent};
716 loader->setPath(QString::fromStdString(ossia::convert<std::string>(
717 resolveControlPath<Field>(inlet->value(), ctx.doc))));
720 inlet, &Process::ControlInlet::valueChanged, loader,
721 [&ctx, weak_node, field = ¶m, loader](
const ossia::value& val) {
722 const auto resolved = resolveControlPath<Field>(val, ctx.doc);
723 con_unvalidated<Node, Field, N, NField>{ctx, weak_node, *field}(resolved);
724 loader->setPath(QString::fromStdString(ossia::convert<std::string>(resolved)));
732template <
typename Field>
734 = !ossia_port<avnd::concrete_port_type<Field>>
735 && (!avnd::dynamic_ports_port<Field>
736 || avnd::parameter_port<avnd::concrete_port_type<Field>>);
738template <
typename Node>
741 using ExecNode = safe_node<Node>;
746 const std::shared_ptr<ExecNode>& node_ptr;
751 template <
typename Field, std::
size_t N, std::
size_t NField>
753 operator()(Field& param, avnd::predicate_index<N> np, avnd::field_index<NField> nf)
755 const auto ports = element.avnd_input_idx_to_model_ports(NField);
757 if constexpr(avnd::dynamic_ports_port<Field>)
759 param.ports.resize(ports.size());
762 if constexpr(field_has_ui_controls<Field>)
767 if(
auto inlet = qobject_cast<Process::ControlInlet*>(p))
770 element, ctx, node_ptr, parent};
772 setup.initialize_control(param, inlet, k);
774 setup.invoke_update(param, k);
776 setup.connect_control_to_ui(control_data, param, inlet, k);
786template <
typename Node>
789 using ExecNode = safe_node<Node>;
794 const std::shared_ptr<ExecNode>& node_ptr;
799 template <
typename Field, std::
size_t N, std::
size_t NField>
801 operator()(Field& param, avnd::predicate_index<N> np, avnd::field_index<NField> nf)
803 if constexpr(field_has_ui_controls<Field>)
805 const auto ports = element.avnd_input_idx_to_model_ports(NField);
809 if(
auto inlet = qobject_cast<Process::ControlInlet*>(p))
812 element, ctx, node_ptr, parent};
817 if(setup.reconnect_control_to_ui(control_data, param, inlet, k))
818 setup.push_current_value(param, inlet, k);
Definition score-plugin-avnd/Crousti/ProcessModel.hpp:123
Definition ExecutorPortSetup.hpp:60
Definition ExecutorPortSetup.hpp:666
TreeNode< DeviceExplorerNode > Node
Definition DeviceNode.hpp:74
Definition Controls.hpp:30
constexpr bool control_value_owns_memory
Definition ExecutorPortSetup.hpp:91
ossia::value resolveControlPath(const ossia::value &v, const score::DocumentContext &ctx)
Definition ExecutorPortSetup.hpp:69
QStringList soundSetExtensions(std::string_view exts)
The extensions a sound_set port lists, from its extensions() string.
Definition SoundSet.cpp:138
constexpr bool field_has_ui_controls
Definition ExecutorPortSetup.hpp:734
Definition ExecutionContext.hpp:208
Definition PortForward.hpp:23
Definition PortForward.hpp:27
Definition ExecutorPortSetup.hpp:177
Definition ExecutorPortSetup.hpp:120
Definition ExecutorPortSetup.hpp:788
Definition ExecutorPortSetup.hpp:740
Definition ExecutorPortSetup.hpp:39
Definition ExecutorPortSetup.hpp:24
Definition ExecutorPortSetup.hpp:101
const void * field
The control, only compared with.
Definition ExecutorPortSetup.hpp:103
bool stale() const noexcept
Audio thread.
Definition ExecutorPortSetup.hpp:111
uint64_t number
Definition ExecutorPortSetup.hpp:107
Definition ExecutorPortSetup.hpp:227
Definition ExecutorPortSetup.hpp:259
void update_controller(Field ¶m, Process::ControlInlet *inlet)
Definition ExecutorPortSetup.hpp:298
bool reconnect_control_to_ui(dynamic_ports_component_data< Node > &control_data, Field ¶m, Process::ControlInlet *inlet, int k)
Definition ExecutorPortSetup.hpp:388
void push_current_value(Field ¶m, Process::ControlInlet *inlet, int k)
Definition ExecutorPortSetup.hpp:430
Definition MessageBus.hpp:75
void retry() noexcept
Writer's thread, at each tick.
Definition MessageBus.hpp:83
Definition DocumentContext.hpp:18