38268703700

Committed 12 Oct 2026 03:13PM UTC coverage: 48.723%. First build

Build # 38268703700

Build Type

Pull #2302

github

Committed by

web-flow

Commit Message

Merge 08e951e4e into 4b2f7f45e

Pull Request Pull Request #2302: Mixer: a console of strips with meters, and the execution reporting back without stopping the audio

Coverage Stats

1430 of 2241 new or added lines in 48 files covered. (63.81%)

159878 of 328135 relevant lines covered (48.72%)

145109.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.31

/src/plugins/score-lib-process/Process/ExecutionSetup.cpp

#include <State/Address.hpp>

#include <Process/Dataflow/Cable.hpp>
#include <Process/Dataflow/Port.hpp>
#include <Process/ExecutionContext.hpp>
#include <Process/ExecutionFunctions.hpp>
#include <Process/ExecutionSetup.hpp>
#include <Process/ExecutionTransaction.hpp>
#include <Process/Process.hpp>

#include <LocalTree/ScriptableProcessComponent.hpp>

#include <QPointer>
#include <QTimer>

#include <ossia/dataflow/execution_state.hpp>
#include <ossia/dataflow/for_each_port.hpp>
#include <ossia/dataflow/graph/graph_interface.hpp>
#include <ossia/dataflow/graph_edge.hpp>
#include <ossia/dataflow/graph_node.hpp>
#include <ossia/dataflow/port.hpp>
#include <ossia/editor/scenario/time_process.hpp>
#include <ossia/network/common/destination_qualifiers.hpp>

namespace Execution
{

namespace
{
struct ContextEnqueuer
{
  SetupContext& self;
  template <typename F>
  void operator()(F&& f)
  {
    static_assert(std::is_nothrow_move_constructible_v<F>);
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
    self.context.executionQueue.enqueue(std::move(f));
  }
};
struct VectorEnqueuer
{
  Transaction& vec;
  template <typename F>
  void operator()(F&& f)
  {
    static_assert(std::is_nothrow_move_constructible_v<F>);
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
    vec.push_back(std::move(f));
  }
};

// Changed from lambda to explicit struct to improve debuggability
static auto enqueue_in_context(SetupContext& self) noexcept
{
  return ContextEnqueuer{self};
}

static auto enqueue_in_vector(Transaction& vec) noexcept
{
  return VectorEnqueuer{vec};
}
}
ossia::net::node_base*
findNode(const ossia::execution_state& st, const State::Address& addr)
{
  auto& devs = st.edit_devices();
  auto dev_p = ossia::find_if(
      devs, [d = addr.device.toStdString()](auto& dev) { return dev->get_name() == d; });
  if(dev_p == devs.end())
    return nullptr;
  return ossia::net::find_node(
      (*dev_p)->get_root_node(), addr.path.join("/").toStdString());
}

std::optional<ossia::destination> makeDestination(
    const ossia::execution_state& devices, const State::AddressAccessor& addr)
{
  auto n = findNode(devices, addr.address);
  if(!n)
    return {};

  auto p = n->get_parameter();
  if(!p)
    return {};

  auto& qual = addr.qualifiers.get();
  return ossia::destination{*p, qual.accessors, qual.unit};
}

template <typename Impl>
void SetupContext::disconnect_cable_impl(const Process::Cable& c, Impl&& impl)
{
  if(!context.created) {
    return;
  }
  auto it = m_cables.find(c.id());
  if(it != m_cables.end())
  {
    impl([cable = it->second, graph = context.execGraph] {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      graph->disconnect(cable);
    });
    // The edge is gone from the graph: a later connectCable() for the same
    // id makes a new one, and whoever asks whether the cable is wired up
    // (a node rebuilding its ports) must not find this one.
    m_cables.erase(it);
  }
}

template <typename Impl>
void SetupContext::connect_cable_impl(Process::Cable& cable, Impl&& impl)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(!context.created) {
    return;
  }
  ossia::node_ptr source_node{}, sink_node{};
  ossia::outlet_ptr source_port{};
  ossia::inlet_ptr sink_port{};
  if(auto port_src = cable.source().try_find(context.doc))
  {
    auto it = outlets.find(port_src);
    if(it != outlets.end())
    {
      source_node = it->second.first;
      source_port = it->second.second;
    }
  }
  if(auto port_snk = cable.sink().try_find(context.doc))
  {
    auto it = inlets.find(port_snk);
    if(it != inlets.end())
    {
      sink_node = it->second.first;
      sink_port = it->second.second;
    }
  }

  if(source_node && sink_node && source_port && sink_port)
  {
    ossia::edge_ptr edge;
    switch(cable.type())
    {
      case Process::CableType::ImmediateStrict: {
        edge = context.execGraph->allocate_edge(
            ossia::immediate_strict_connection{}, std::move(source_port),
            std::move(sink_port), std::move(source_node), std::move(sink_node));
        break;
      }
      case Process::CableType::ImmediateGlutton: {
        edge = context.execGraph->allocate_edge(
            ossia::immediate_glutton_connection{}, std::move(source_port),
            std::move(sink_port), std::move(source_node), std::move(sink_node));
        break;
      }
      case Process::CableType::DelayedStrict: {
        edge = context.execGraph->allocate_edge(
            ossia::delayed_strict_connection{}, std::move(source_port),
            std::move(sink_port), std::move(source_node), std::move(sink_node));
        break;
      }
      case Process::CableType::DelayedGlutton: {
        edge = context.execGraph->allocate_edge(
            ossia::delayed_glutton_connection{}, std::move(source_port),
            std::move(sink_port), std::move(source_node), std::move(sink_node));
        break;
      }
    }

    m_cables[cable.id()] = edge;
    impl([edge, graph = context.execGraph]() mutable {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      graph->connect(std::move(edge));
    });
  }
}

// Pushed once, when the node is registered; the address machinery never touches
// `type` afterwards.
template <typename T, typename Impl>
static void set_declared_unit_impl(
    const Process::Port& proc_port, const T& port, Impl&& append)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  const ossia::unit_t& u = proc_port.unit().get();
  if(!u)
    return;

  append([port, u] {
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
    if(ossia::value_port* dat = port->template target<ossia::value_port>())
    {
      // A unit the node declared is more precise than the widget's and wins; a
      // plain value type does not.
      if(!dat->type.target<ossia::unit_t>())
        dat->type = u;
    }
  });
}

// Without an explicit address, a scriptable port uses its published parameter
static State::AddressAccessor effectiveAddress(const Process::Port& port)
{
  if(port.address().isSet())
    return port.address();
  return State::AddressAccessor{LocalTree::scriptableAddress(port)};
}

template <typename Port_T, typename OssiaPort_T, typename Impl>
void SetupContext::bind_address(
    Port_T& proc_port, const OssiaPort_T& ossia_port,
    RegisteredPorts::connections& cons, Impl&& impl)
{
  for(auto& con : cons)
    QObject::disconnect(con);
  cons.clear();

  // The ossia port is looked up when this runs: a queued call can arrive after
  // a program change has replaced the one the port was bound with.
  auto rebind = [this, port = QPointer<Process::Port>{&proc_port}] {
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
    if(port)
      this->rebind(port.data());
  };
  cons.push_back(connect(&proc_port, &Process::Port::addressChanged, this, rebind));
  // Queued: the namespace updates the published address on these signals too
  cons.push_back(connect(
      &proc_port, &Process::Port::scriptableChanged, this, rebind, Qt::QueuedConnection));
  cons.push_back(connect(
      &proc_port, &Process::Port::exposedChanged, this, rebind, Qt::QueuedConnection));
  if(auto proc = Process::parentProcess(&proc_port))
    cons.push_back(connect(
        proc, &Process::ProcessModel::scriptableChanged, this, rebind,
        Qt::QueuedConnection));
  follow_published();
  set_declared_unit_impl(proc_port, ossia_port, impl);

  // Also registers the port with the execution state once the address resolves.
  set_destination_impl(context, effectiveAddress(proc_port), ossia_port, impl);
}

template <typename Impl>
void SetupContext::register_inlet_impl(
    Process::Inlet& proc_port, const ossia::inlet_ptr& ossia_port,
    const std::shared_ptr<ossia::graph_node>& node, Impl&& impl)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  SCORE_ASSERT(node);
  SCORE_ASSERT(ossia_port);

  bind_address(proc_port, ossia_port, runtime_connections[node].inlets[proc_port.id()], impl);

  inlets.insert({&proc_port, std::make_pair(node, ossia_port)});
}

template <typename Impl>
void SetupContext::register_node_impl(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node, Impl&& exec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    std::weak_ptr<ossia::graph_interface> wg = context.execGraph;
    exec([wg, node = node]() mutable {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      if(auto g = wg.lock())
        g->add_node(std::move(node));
    });

    const std::size_t proc_n_inlets = proc_inlets.size();
    const std::size_t proc_n_outlets = proc_outlets.size();

    const std::size_t ossia_n_inlets = node->root_inputs().size();
    const std::size_t ossia_n_outlets = node->root_outputs().size();

    std::size_t n_inlets = std::min(proc_n_inlets, ossia_n_inlets);
    std::size_t n_outlets = std::min(proc_n_outlets, ossia_n_outlets);

    for(std::size_t i = 0; i < n_inlets; i++)
    {
      register_inlet_impl(*proc_inlets[i], node->root_inputs()[i], node, exec);
    }

    for(std::size_t i = 0; i < n_outlets; i++)
    {
      register_outlet_impl(*proc_outlets[i], node->root_outputs()[i], node, exec);
    }
  }
}

void SetupContext::register_node(
    const Process::ProcessModel& proc, const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_node(proc.inlets(), proc.outlets(), node);
  proc_map[node.get()] = &proc;
}

void SetupContext::unregister_node(
    const Process::ProcessModel& proc, const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  unregister_node(proc.inlets(), proc.outlets(), node);
  proc_map.erase(node.get());
}

void SetupContext::register_node(
    const Process::ProcessModel& proc, const std::shared_ptr<ossia::graph_node>& node,
    Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_node(proc.inlets(), proc.outlets(), node, vec);
  proc_map[node.get()] = &proc;
}

void SetupContext::unregister_node(
    const Process::ProcessModel& proc, const std::shared_ptr<ossia::graph_node>& node,
    Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  unregister_node(proc.inlets(), proc.outlets(), node, vec);
  proc_map.erase(node.get());
}

template <typename T, typename Impl>
void set_destination_impl(
    const Context& plug, const State::AddressAccessor& address, const T& port,
    Impl&& append)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  auto& s = plug.execState;
  auto& g = plug.execGraph;
  if(!g)
    return;

  if(address.address.device.isEmpty())
  {
    append([ws = std::weak_ptr{s}, port, wg = std::weak_ptr{g}] {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      auto s = ws.lock();
      if(!s)
        return;
      auto g = wg.lock();
      if(!g)
        return;
      if(port->address)
      {
        s->unregister_port(*port);
        port->address = {};
        if(ossia::value_port* dat = port->template target<ossia::value_port>())
        {
          dat->address_unit = {};
          dat->index = {};
        }
        g->mark_dirty();
      }
    });
    return;
  }

  auto& qual = address.qualifiers.get();
  if(auto n = findNode(*plug.execState, address.address))
  {
    auto p = n->get_parameter();
    if(p)
    {
      append([ws = std::weak_ptr{s}, port, p, qual = qual, wg = std::weak_ptr{g}] {
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        auto s = ws.lock();
        if(!s)
          return;
        auto g = wg.lock();
        if(!g)
          return;
        s->unregister_port(*port);
        port->address = p;
        if(ossia::value_port* dat = port->template target<ossia::value_port>())
        {
          // Unconditionally, like the index: dropping the qualifier has to give
          // the process's declaration back.
          dat->address_unit = qual.unit;
          dat->index = qual.accessors;
        }
        s->register_port(*port);
        g->mark_dirty();
      });
    }
    else
    {
      append([ws = std::weak_ptr{s}, n, port, wg = std::weak_ptr{g}] {
        auto s = ws.lock();
        if(!s)
          return;
        auto g = wg.lock();
        if(!g)
          return;
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        s->unregister_port(*port);
        port->address = n;
        s->register_port(*port);
        g->mark_dirty();
      });
    }
  }
  else if(auto ad = address.address.toString_unsafe().toStdString();
          ossia::traversal::is_pattern(ad))
  {
    // OPTIMIZEME
    auto path = ossia::traversal::make_path(ad);
    if(path)
    {
      append([ws = std::weak_ptr{s}, p = *path, port, wg = std::weak_ptr{g}]() mutable {
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        auto s = ws.lock();
        if(!s)
          return;
        auto g = wg.lock();
        if(!g)
          return;
        s->unregister_port(*port);
        port->address = std::move(p);
        if(ossia::value_port* dat = port->template target<ossia::value_port>())
        {
          dat->address_unit = {};
          dat->index.clear();
        }
        s->register_port(*port);
        g->mark_dirty();
      });
    }
    else
    {
      append([ws = std::weak_ptr{s}, n, port, wg = std::weak_ptr{g}] {
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        auto s = ws.lock();
        if(!s)
          return;
        auto g = wg.lock();
        if(!g)
          return;
        s->unregister_port(*port);
        port->address = {};
        if(ossia::value_port* dat = port->template target<ossia::value_port>())
        {
          dat->address_unit = {};
          dat->index.clear();
        }
        s->register_port(*port);
        g->mark_dirty();
      });
    }
  }
}

void SetupContext::set_destination(
    const State::AddressAccessor& address, const ossia::inlet_ptr& port)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  set_destination_impl(context, address, port, enqueue_in_context(*this));
}

void SetupContext::set_destination(
    const State::AddressAccessor& address, const ossia::outlet_ptr& port)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  set_destination_impl(context, address, port, enqueue_in_context(*this));
}

void SetupContext::register_inlet(
    Process::Inlet& inlet, const ossia::inlet_ptr& exec,
    const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_inlet_impl(inlet, exec, node, enqueue_in_context(*this));
}
void SetupContext::register_outlet(
    Process::Outlet& outlet, const ossia::outlet_ptr& exec,
    const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_outlet_impl(outlet, exec, node, enqueue_in_context(*this));
}

void SetupContext::register_node(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_node_impl(proc_inlets, proc_outlets, node, enqueue_in_context(*this));
}

void SetupContext::register_node(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_node_impl(proc_inlets, proc_outlets, node, enqueue_in_vector(vec));
}

void SetupContext::register_inlet(
    Process::Inlet& inlet, const ossia::inlet_ptr& exec,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_inlet_impl(inlet, exec, node, enqueue_in_vector(vec));
}
void SetupContext::register_outlet(
    Process::Outlet& outlet, const ossia::outlet_ptr& exec,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  register_outlet_impl(outlet, exec, node, enqueue_in_vector(vec));
}

void SetupContext::on_cableCreated(Process::Cable& c)
{
  connectCable(c);
}

void SetupContext::on_cableRemoved(const Process::Cable& c)
{
  removeCable(c);
}

void SetupContext::connectCable(Process::Cable& c)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  connect_cable_impl(c, enqueue_in_context(*this));
}

void SetupContext::connectCable(Process::Cable& c, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  connect_cable_impl(c, enqueue_in_vector(vec));
}

void SetupContext::removeCable(const Process::Cable& c)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  disconnect_cable_impl(c, enqueue_in_context(*this));
}

void SetupContext::removeCable(const Process::Cable& c, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  disconnect_cable_impl(c, enqueue_in_vector(vec));
}

// What a process sends goes through its outlet's gain, pan and upmix, which
// follow the model.
template <typename Impl>
void SetupContext::register_mixing_impl(
    Process::AudioOutlet& proc_port, ossia::audio_outlet& out,
    const std::shared_ptr<ossia::graph_node>& node, Impl&& impl)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  auto* o = &out;
  const auto weights = proc_port.pan();
  impl([node, o, g = proc_port.gain(),
        pan = ossia::pan_weight(weights.begin(), weights.end()),
        mode = proc_port.upmixMode(), chans = proc_port.upmixChannels()]() mutable {
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
    o->gain = g;
    // A swap: the previous weights are freed with this closure, off the audio
    // thread.
    std::swap(o->pan, pan);
    o->upmix = ossia::audio_outlet::upmix_mode(mode);
    o->upmix_channels = chans;
  });

  auto& ports = runtime_connections[node];
  ports.disconnectMixing(proc_port.id());
  auto& cons = ports.mixing[proc_port.id()];
  auto& q = context.executionQueue;
  cons[0] = connect(&proc_port, &Process::AudioOutlet::gainChanged, this, [&q, node, o](double g) {
    q.enqueue([node, o, g] { o->gain = g; });
  });
  cons[1] = connect(
      &proc_port, &Process::AudioOutlet::panChanged, this,
      [&q, node, o](const auto& w) {
    q.enqueue([node, o, pan = ossia::pan_weight(w.begin(), w.end())]() mutable {
      std::swap(o->pan, pan);
    });
  });
  auto upmix = [&q, node, o, port = &proc_port] {
    q.enqueue([node, o, mode = port->upmixMode(), chans = port->upmixChannels()] {
      o->upmix = ossia::audio_outlet::upmix_mode(mode);
      o->upmix_channels = chans;
    });
  };
  cons[2] = connect(&proc_port, &Process::AudioOutlet::upmixModeChanged, this, upmix);
  cons[3] = connect(&proc_port, &Process::AudioOutlet::upmixChannelsChanged, this, upmix);
}

template <typename Impl>
void SetupContext::register_outlet_impl(
    Process::Outlet& proc_port, const ossia::outlet_ptr& ossia_port,
    const std::shared_ptr<ossia::graph_node>& node, Impl&& impl)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  SCORE_ASSERT(node);
  SCORE_ASSERT(ossia_port);
  bind_address(
      proc_port, ossia_port, runtime_connections[node].outlets[proc_port.id()], impl);

  if(auto audio = qobject_cast<Process::AudioOutlet*>(&proc_port);
     audio && ossia_port->which() == ossia::audio_port::which)
    register_mixing_impl(
        *audio, *static_cast<ossia::audio_outlet*>(ossia_port), node, impl);

  outlets.insert({&proc_port, std::make_pair(node, ossia_port)});

  proc_port.mapExecution(
      *ossia_port, [&](Process::Inlet& model_inl, ossia::inlet& ossia_inl) {
        register_inlet_impl(model_inl, &ossia_inl, node, impl);
      });

  // Unneeded : the execution_state only needs inlets to be registered,
  // in order to set up data value queues from the network thread

  // std::weak_ptr<ossia::execution_state> ws = context.execState;
  // impl([ws, ossia_port] {
  //   if (auto state = ws.lock())
  //     state->register_outlet(*ossia_port);
  // });
}

void SetupContext::unregister_inlet(
    const Process::Inlet& proc_port, const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    auto& runtime_connection = runtime_connections[node].inlets;
    auto it = runtime_connection.find(proc_port.id());
    if(it != runtime_connection.end())
    {
      for(auto& con : it->second)
        QObject::disconnect(con);
      runtime_connection.erase(it);
    }

    auto ossia_port_it = inlets.find(const_cast<Process::Inlet*>(&proc_port));
    if(ossia_port_it != inlets.end())
    {
      std::weak_ptr<ossia::execution_state> ws = context.execState;
      context.executionQueue.enqueue([ws, ossia_port = ossia_port_it->second.second] {
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        if(auto state = ws.lock())
          state->unregister_port(*ossia_port);
      });

      inlets.erase(ossia_port_it);
    }
  }
  else
  {
    inlets.erase(const_cast<Process::Inlet*>(&proc_port));
  }
}

void SetupContext::unregister_outlet(
    const Process::Outlet& proc_port, const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    auto& runtime_connection = runtime_connections[node].outlets;
    auto it = runtime_connection.find(proc_port.id());
    if(it != runtime_connection.end())
    {
      for(auto& con : it->second)
        QObject::disconnect(con);
      runtime_connection.erase(it);
    }
    runtime_connections[node].disconnectMixing(proc_port.id());

    proc_port.forChildInlets([&](Process::Inlet& model_inl) {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      unregister_inlet(model_inl, node);
    });
  }

  outlets.erase(const_cast<Process::Outlet*>(&proc_port));
}

void SetupContext::unregister_inlet(
    const Process::Inlet& proc_port, const std::shared_ptr<ossia::graph_node>& node,
    Transaction& commands)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    auto& runtime_connection = runtime_connections[node].inlets;
    auto it = runtime_connection.find(proc_port.id());
    if(it != runtime_connection.end())
    {
      for(auto& con : it->second)
        QObject::disconnect(con);
      runtime_connection.erase(it);
    }

    auto ossia_port_it = inlets.find(const_cast<Process::Inlet*>(&proc_port));
    if(ossia_port_it != inlets.end())
    {
      std::weak_ptr<ossia::execution_state> ws = context.execState;
      commands.push_back([ws, ossia_port = ossia_port_it->second.second] {
        OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
        if(auto state = ws.lock())
          state->unregister_port(*ossia_port);
      });

      inlets.erase(ossia_port_it);
    }
  }
  else
  {
    inlets.erase(const_cast<Process::Inlet*>(&proc_port));
  }
}

void SetupContext::unregister_outlet(
    const Process::Outlet& proc_port, const std::shared_ptr<ossia::graph_node>& node,
    Transaction& commands)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    auto& runtime_connection = runtime_connections[node].outlets;
    auto it = runtime_connection.find(proc_port.id());
    if(it != runtime_connection.end())
    {
      for(auto& con : it->second)
        QObject::disconnect(con);
      runtime_connection.erase(it);
    }
    runtime_connections[node].disconnectMixing(proc_port.id());

    proc_port.forChildInlets([&](Process::Inlet& model_inl) {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      unregister_inlet(model_inl, node);
    });
  }

  outlets.erase(const_cast<Process::Outlet*>(&proc_port));
}

void SetupContext::replace_node(
    const std::shared_ptr<ossia::time_process>& process,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& commands)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  commands.push_back([p = process, n = node]() mutable {
    OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
    using namespace std;
    swap(p->node, n);
  });
}

void SetupContext::unregister_node(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    std::weak_ptr<ossia::graph_interface> wg = context.execGraph;
    std::weak_ptr<ossia::execution_state> ws = context.execState;
    context.executionQueue.enqueue([wg, ws, node = node] mutable {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      if(auto s = ws.lock())
      {
        ossia::for_each_inlet(*node, [&](auto& p) { s->unregister_port(p); });
        ossia::for_each_outlet(*node, [&](auto& p) { s->unregister_port(p); });
      }

      if(auto g = wg.lock())
        g->remove_node(node);

      node->clear();
    });

    runtime_connections[node].clear();
    runtime_connections.erase(node);

    proc_map.erase(node.get());
  }

  for(auto ptr : proc_inlets)
    inlets.erase(ptr);
  for(auto ptr : proc_outlets)
    outlets.erase(ptr);
}

void SetupContext::unregister_node(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    std::weak_ptr<ossia::graph_interface> wg = context.execGraph;
    std::weak_ptr<ossia::execution_state> ws = context.execState;
    vec.push_back([wg, ws, node] {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      if(auto s = ws.lock())
      {
        ossia::for_each_inlet(*node, [&](auto& p) { s->unregister_port(p); });
        ossia::for_each_outlet(*node, [&](auto& p) { s->unregister_port(p); });
      }

      if(auto g = wg.lock())
        g->remove_node(node);
      node->clear();
    });

    runtime_connections[node].clear();
    runtime_connections.erase(node);

    proc_map.erase(node.get());
  }

  for(auto ptr : proc_inlets)
    inlets.erase(ptr);
  for(auto ptr : proc_outlets)
    outlets.erase(ptr);
}

void SetupContext::unregister_node_soft(
    const Process::Inlets& proc_inlets, const Process::Outlets& proc_outlets,
    const std::shared_ptr<ossia::graph_node>& node, Transaction& vec)
{
  OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Ui);
  if(node)
  {
    std::weak_ptr<ossia::execution_state> ws = context.execState;
    vec.push_back([ws, node] {
      OSSIA_ENSURE_CURRENT_THREAD_KIND(ossia::thread_type::Audio);
      if(auto s = ws.lock())
      {
        ossia::for_each_inlet(*node, [&](auto& p) { s->unregister_port(p); });
        ossia::for_each_outlet(*node, [&](auto& p) { s->unregister_port(p); });
      }
    });
    runtime_connections[node].clear();
    runtime_connections.erase(node);

    proc_map.erase(node.get());
  }

  for(auto ptr : proc_inlets)
    inlets.erase(ptr);
  for(auto ptr : proc_outlets)
    outlets.erase(ptr);
}

SetupContext::SetupContext(Context& other) noexcept
    : context{other}
{
}

void SetupContext::follow_published()
{
  if(m_followsPublished)
    return;
  m_followsPublished = true;
  // Rebinds ports published after setup, e.g. restored by undo during playback
  if(auto tree = context.doc.findPlugin<LocalTree::ScriptableTreeBase>())
    connect(tree, &LocalTree::ScriptableTreeBase::published, this, [this](QObject* object) {
      QTimer::singleShot(0, this, [this, object = QPointer<QObject>{object}] {
        if(object)
          rebind(object.data());
      });
    });
}

void SetupContext::rebind(QObject* port)
{
  if(auto in = qobject_cast<Process::Inlet*>(port))
  {
    if(auto it = inlets.find(in); it != inlets.end())
      set_destination(effectiveAddress(*in), it->second.second);
  }
  else if(auto out = qobject_cast<Process::Outlet*>(port))
  {
    if(auto it = outlets.find(out); it != outlets.end())
      set_destination(effectiveAddress(*out), it->second.second);
  }
}

SetupContext::~SetupContext() { }

}

ossia / score / 38268703700

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous