38475390298

Committed 13 Oct 2026 09:56PM UTC coverage: 48.898% (+0.8%) from 48.076%

Build # 38475390298

Build Type

push

github

Committed by

jcelerier

Commit Message

gfx: commit the initial batch before a frame can release what it names

RenderList::renderImpl carried m_initialBatch, holding every renderer's
init()-time uploads, into the frame's first pass. When an inlet spec changed
before that first frame, the surgical render-target update released and
re-initialised the renderer first, and releaseState() deletes its material
UBO outright, so the batch then named a freed QRhiBuffer. On OpenGL,
enqueueResourceUpdates copies a uniform-buffer update into the buffer's
CPU-side store: a write into freed memory, or, after destroy() cleared it,
into QByteArray's static empty storage. test_gfx_input_sampler_filter
(raw raster, OpenGL) crashed there, or read back black, depending on what
reused the allocation.

The batch is now committed to the command buffer as soon as the frame takes
it, as onEdgeRemoved() and Graph::relinkGraph() already flush it before
releasing renderer state.

The new case in test_gfx_outside_frame_release_buffer re-inits a probe
renderer on the first frame and checks, from its releaseState(), whether the
batch its upload went into still holds it: deterministic, on every backend.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JeL19ofVgPe9u9q7J1V9ex

Coverage Stats

2 of 2 new or added lines in 1 file covered. (100.0%)

6331 existing lines in 89 files now uncovered.

160459 of 328149 relevant lines covered (48.9%)

146726.48 hits per line

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

62.71

/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);
  if(plug.retired)
    return;
  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)
{
  if(context.retired)
    return;
  connectCable(c);
}

void SetupContext::on_cableRemoved(const Process::Cable& c)
{
  if(context.retired)
    return;
  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));
}

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);

  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);
    }

    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);
    }

    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(context.retired)
    return;
  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 / 38475390298

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