score-plugin-lv2/LV2/Node.hpp

#pragma once
#include <LV2/Context.hpp>
#include <LV2/lv2_atom_helpers.hpp>
 
#include <ossia/dataflow/fx_node.hpp>
#include <ossia/dataflow/port.hpp>
#include <ossia/detail/fmt.hpp>
#include <ossia/detail/lockfree_queue.hpp>
#include <ossia/detail/pod_vector.hpp>
#include <ossia/detail/small_vector.hpp>
 
#include <libremidi/detail/conversion.hpp>
 
#include <QCoreApplication>
 
#include <lilv/lilv.h>
 
#include <algorithm>
#include <memory>
#include <optional>
#include <type_traits>
#include <vector>
 
namespace LV2
{
 
// One LilvInstance + per-voice scratch / atom buffers. Pinned (TimePort holds pointers).
struct voice
{
  SharedInstance instance_holder;
  LilvInstance* instance{}; // cached: instance_holder->instance
 
  ossia::float_vector fInControls;
  ossia::float_vector fOutControls;
  ossia::float_vector fOtherControls;
  std::vector<ossia::float_vector> fCVs;
  std::vector<ossia::float_vector> fCVOuts;
 
  std::vector<ossia::float_vector> audio_in_scratch;
  std::vector<ossia::float_vector> audio_out_scratch;
 
  std::vector<AtomBuffer> midi_atom_ins;
  std::vector<AtomBuffer> midi_atom_outs;
  std::vector<libremidi::midi2_to_midi1_assembler<>> midi_2to1;
  std::vector<libremidi::midi1_to_midi2> midi_1to2;
  std::vector<ossia::small_vector<Message, 2>> message_for_midi_atom_ins;
 
  std::vector<AtomBuffer> atom_ins;
  std::vector<AtomBuffer> atom_outs;
  std::vector<ossia::small_vector<Message, 2>> message_for_atom_ins;
  std::vector<AtomBuffer> atom_others;
 
  struct TimePort
  {
    int port;
    AtomBuffer* buffer{};
  };
  std::vector<TimePort> atom_timePosition_midi;
  std::vector<AtomBuffer> atom_timePosition_owned_buffers;
  std::vector<TimePort> atom_timePosition_owned;
 
  const LV2_Worker_Interface* worker{};
  ossia::mpmc_queue<std::vector<char>> worker_datas;
 
  uint32_t port_count{};
 
  voice() = default;
  voice(const voice&) = delete;
  voice& operator=(const voice&) = delete;
  voice(voice&&) = delete;
  voice& operator=(voice&&) = delete;
 
  ~voice() noexcept
  {
    if(!instance_holder || !instance || instance_holder->connected_to != this)
      return;
    if(instance_holder->activated)
    {
      lilv_instance_deactivate(instance);
      instance_holder->activated = false;
    }
    park_ports();
  }
 
  void park_ports() noexcept
  {
    if(!instance_holder || !instance || instance_holder.use_count() < 2
       || instance_holder->connected_to != this)
      return;
    alignas(64) static float parking[2 * 4096 + 64]{};
    for(uint32_t p = 0; p < port_count; p++)
      lilv_instance_connect_port(instance, p, parking);
    instance_holder->connected_to = nullptr;
  }
};
 
enum class voice_routing : std::uint8_t
{
  single,
  // N voices, channel c -> voice c (mono plug-in on multichannel bus)
  per_channel
};
 
struct voice_strategy
{
  voice_routing routing{voice_routing::single};
  std::size_t voice_count{1};
};
 
// 1-in/1-out plug-ins get N replicated voices for multichannel host buses
inline voice_strategy
choose_voice_strategy(const LV2Data& data, std::size_t replicate_count = 8) noexcept
{
  const auto ains = data.audio_in_ports.size();
  const auto aouts = data.audio_out_ports.size();
  if(ains == 1 && aouts == 1 && replicate_count > 1)
    return {voice_routing::per_channel, replicate_count};
  return {voice_routing::single, 1};
}
 
template <typename OnExecStart, typename OnExecFinished>
struct lv2_node final : public ossia::graph_node
{
  LV2Data data;
  std::vector<std::unique_ptr<voice>> voices;
  voice_routing routing{voice_routing::single};
 
  ossia::float_vector fParamMin, fParamMax, fParamInit;
  ossia::float_vector fInScale, fOutScale;
  std::unique_ptr<uint8_t[]> timePositionBuffer{};
  std::unique_ptr<uint8_t[]> stoppedPositionBuffer{};
  bool m_sendStopped{true};
  bool mustStop{};
  bool m_timeForged{};
 
  // Matches LV2_BUF_SIZE__maxBlockLength advertised in Context.cpp
  std::size_t max_block_size{4096};
 
  // Audio-thread high-water mark; monotonic; main-thread grower reads via in_exec
  std::atomic<std::size_t> requested_voices{0};
 
  OnExecStart on_start;
  OnExecFinished on_finished;
 
  // Avoids RT-unfriendly realloc in append_voice for common channel counts
  static constexpr std::size_t kVoicePoolReserve = 256;
 
  lv2_node(
      const LV2Data& dat, int sampleRate, voice_strategy strat, OnExecStart os,
      OnExecFinished of)
      : data{dat}
      , routing{strat.routing}
      , on_start{os}
      , on_finished{of}
  {
    this->set_not_fp_safe();
 
    if(strat.voice_count < 1)
      strat.voice_count = 1;
 
    const auto audio_in_size = data.audio_in_ports.size();
    const auto audio_out_size = data.audio_out_ports.size();
    const auto cv_size = data.cv_ports.size();
    const auto midi_in_size = data.midi_in_ports.size();
    const auto midi_out_size = data.midi_out_ports.size();
    const auto atom_in_size = data.atom_in_ports.size();
    const auto atom_out_size = data.atom_out_ports.size();
    const auto control_in_size = data.control_in_ports.size();
    const auto control_out_size = data.control_out_ports.size();
 
    if(audio_in_size > 0)
      m_inlets.push_back(new ossia::audio_inlet);
    if(audio_out_size > 0)
      m_outlets.push_back(new ossia::audio_outlet);
    for(std::size_t i = 0; i < cv_size; i++)
      m_inlets.push_back(new ossia::audio_inlet);
    for(std::size_t i = 0; i < midi_in_size; i++)
      m_inlets.push_back(new ossia::midi_inlet);
    for(std::size_t i = 0; i < midi_out_size; i++)
      m_outlets.push_back(new ossia::midi_outlet);
    for(std::size_t i = 0; i < atom_in_size; i++)
      m_inlets.push_back(new ossia::value_inlet);
    for(std::size_t i = 0; i < atom_out_size; i++)
      m_outlets.push_back(new ossia::value_outlet);
    for(std::size_t i = 0; i < control_in_size; i++)
      m_inlets.push_back(new ossia::value_inlet);
    for(std::size_t i = 0; i < control_out_size; i++)
      m_outlets.push_back(new ossia::value_outlet);
    for(std::size_t i = 0; i < data.cv_out_ports.size(); i++)
      m_outlets.push_back(new ossia::audio_outlet);
 
    data.portRanges(fParamMin, fParamMax, fParamInit);
    fInScale.resize(control_in_size);
    for(std::size_t i = 0; i < control_in_size; i++)
      fInScale[i] = data.isSampleRatePort(data.control_in_ports[i]) ? sampleRate : 1.f;
    fOutScale.resize(control_out_size);
    for(std::size_t i = 0; i < control_out_size; i++)
      fOutScale[i] = data.isSampleRatePort(data.control_out_ports[i]) ? sampleRate : 1.f;
 
    if(!data.effect.instance_holder)
      throw std::runtime_error("Error while creating a LV2 plug-in");
 
    voices.reserve(
        routing == voice_routing::per_channel ? kVoicePoolReserve : strat.voice_count);
 
    // A plug-in without activate() has no way to start over (x42's MIDI
    // generator keeps playing from where it stopped): a play starts on a
    // fresh instance, with the state of the previous one. Not while its UI is
    // open, which talks to the current instance.
    if(auto* desc = lilv_instance_get_descriptor(data.effect.instance);
       desc && !desc->activate && !data.effect.ui_instance)
      renew_primary_instance(sampleRate);
 
    // Voice 0 reuses the Model's primary instance across play->stop->play
    voices.push_back(build_voice(data.effect.instance_holder));
 
    // Snapshot so extras inherit loaded samples/models; ports seeded separately below
    LilvState* primary_state = (strat.voice_count > 1) ? snapshot_state_raw() : nullptr;
 
    // lv2_node is constructed on the main thread; LV2EffectComponent grows past this
    for(std::size_t i = 1; i < strat.voice_count; ++i)
    {
      auto handle = instantiate_handle(sampleRate);
      if(!handle)
        break;
      if(primary_state)
        lilv_state_restore(
            primary_state, handle->instance, nullptr, nullptr,
            LV2_STATE_IS_PORTABLE, nullptr);
      voices.push_back(build_voice(std::move(handle)));
    }
 
    if(primary_state)
      lilv_state_free(primary_state);
 
    if(!data.time_Position_ports.empty())
    {
      timePositionBuffer = std::make_unique<uint8_t[]>(256);
      stoppedPositionBuffer = std::make_unique<uint8_t[]>(256);
    }
 
    requested_voices.store(voices.size(), std::memory_order_relaxed);
  }
 
  ~lv2_node() noexcept override
  {
    // May run on audio thread; voice cleanup is main-thread-only per LV2 spec
    if(voices.empty())
      return;
    QMetaObject::invokeMethod(
        QCoreApplication::instance(),
        [pending = std::move(voices)]() mutable { pending.clear(); });
  }
 
  // [main thread]
  std::unique_ptr<voice> build_voice(SharedInstance handle)
  {
    auto v = std::make_unique<voice>();
    v->instance_holder = std::move(handle);
    v->instance = v->instance_holder->instance;
    v->port_count = data.effect.plugin.get_num_ports();
    allocate_voice_buffers(*v);
    connect_voice_ports(*v);
    v->instance_holder->connected_to = v.get();
    activate_voice(*v);
    return v;
  }
 
  // [main thread]
  SharedInstance instantiate_handle(int sampleRate)
  {
    auto* inst = lilv_plugin_instantiate(
        data.effect.plugin.me, sampleRate,
        data.host.global ? data.host.global->features() : data.host.features);
    if(!inst)
      return {};
    return std::make_shared<InstanceHandle>(inst);
  }
 
  // [main thread] Replaces the Model's instance by a new one in the same state.
  void renew_primary_instance(int sampleRate)
  {
    auto handle = instantiate_handle(sampleRate);
    if(!handle)
      return;
    if(data.host.global)
    {
      if(LilvState* state = lilv_state_new_from_instance(
             data.effect.plugin.me, data.effect.instance, &data.host.global->map,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
             LV2_STATE_IS_PORTABLE, nullptr))
      {
        lilv_state_restore(
            state, handle->instance, nullptr, nullptr, LV2_STATE_IS_PORTABLE, nullptr);
        lilv_state_free(state);
      }
    }
    data.effect.instance = handle->instance;
    data.effect.instance_holder = std::move(handle);
  }
 
  // [main thread] null on failure; grower retries next tick
  std::unique_ptr<voice>
  make_voice_for_pool(int sampleRate, LilvState* state)
  {
    auto handle = instantiate_handle(sampleRate);
    if(!handle)
      return nullptr;
 
    if(state)
      lilv_state_restore(
          state, handle->instance, nullptr, nullptr, LV2_STATE_IS_PORTABLE,
          nullptr);
 
    return build_voice(std::move(handle));
  }
 
  // [main thread] Caller frees with lilv_state_free
  LilvState* snapshot_state_raw() const noexcept
  {
    if(voices.empty() || !voices[0]->instance || !data.host.global)
      return nullptr;
    return lilv_state_new_from_instance(
        data.effect.plugin.me, voices[0]->instance, &data.host.global->map,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        LV2_STATE_IS_PORTABLE, nullptr);
  }
 
  // [audio thread] from main-thread grower via in_exec
  void append_voice(std::unique_ptr<voice> v) noexcept
  {
    voices.push_back(std::move(v));
  }
 
  // [audio thread] Monotonic high-water mark
  void request_voice_count(std::size_t n) noexcept
  {
    auto prev = requested_voices.load(std::memory_order_relaxed);
    while(n > prev
          && !requested_voices.compare_exchange_weak(
              prev, n, std::memory_order_release, std::memory_order_relaxed))
      ;
  }
 
  void allocate_voice_buffers(voice& v)
  {
    const auto control_in_size = data.control_in_ports.size();
    const auto control_out_size = data.control_out_ports.size();
    const auto cv_size = data.cv_ports.size();
    const auto other_size = data.control_other_ports.size();
    const auto midi_in_size = data.midi_in_ports.size();
    const auto midi_out_size = data.midi_out_ports.size();
    const auto atom_in_size = data.atom_in_ports.size();
    const auto atom_out_size = data.atom_out_ports.size();
    const auto audio_in_size = data.audio_in_ports.size();
    const auto audio_out_size = data.audio_out_ports.size();
 
    v.fInControls.resize(control_in_size);
    v.fOutControls.resize(control_out_size);
    v.fOtherControls.resize(other_size);
 
    v.fCVs.resize(cv_size);
    for(auto& cv : v.fCVs)
      cv.resize(max_block_size);
    v.fCVOuts.resize(data.cv_out_ports.size());
    for(auto& cv : v.fCVOuts)
      cv.resize(max_block_size);
 
    v.audio_in_scratch.resize(audio_in_size);
    for(auto& a : v.audio_in_scratch)
      a.resize(max_block_size);
 
    v.audio_out_scratch.resize(audio_out_size);
    for(auto& a : v.audio_out_scratch)
      a.resize(max_block_size);
 
    v.midi_atom_ins.reserve(midi_in_size);
    v.midi_2to1.resize(midi_in_size);
    v.message_for_midi_atom_ins.resize(midi_in_size);
    for(std::size_t i = 0; i < midi_in_size; i++)
      v.midi_atom_ins.emplace_back(
          data.atomBufferSize(data.midi_in_ports[i]), data.host.atom_chunk_id,
          data.host.atom_sequence_id, true);
 
    v.midi_atom_outs.reserve(midi_out_size);
    v.midi_1to2.resize(midi_out_size);
    for(std::size_t i = 0; i < midi_out_size; i++)
      v.midi_atom_outs.emplace_back(
          data.atomBufferSize(data.midi_out_ports[i]), data.host.atom_chunk_id,
          data.host.atom_sequence_id, false);
 
    v.atom_ins.reserve(atom_in_size);
    v.message_for_atom_ins.resize(atom_in_size);
    for(std::size_t i = 0; i < atom_in_size; i++)
      v.atom_ins.emplace_back(
          data.atomBufferSize(data.atom_in_ports[i]), data.host.atom_chunk_id,
          data.host.atom_sequence_id, true);
 
    v.atom_outs.reserve(atom_out_size);
    for(std::size_t i = 0; i < atom_out_size; i++)
      v.atom_outs.emplace_back(
          data.atomBufferSize(data.atom_out_ports[i]), data.host.atom_chunk_id,
          data.host.atom_sequence_id, false);
 
    v.atom_others.reserve(data.atom_other_ports.size());
    for(int port : data.atom_other_ports)
      v.atom_others.emplace_back(
          data.atomBufferSize(port), data.host.atom_chunk_id,
          data.host.atom_sequence_id, true);
 
    // time:Position may share a MIDI port (atom:supports midi+time) or have its own atom port
    v.atom_timePosition_owned_buffers.reserve(data.time_Position_ports.size());
    for(int port_index : data.time_Position_ports)
    {
      bool shared = false;
      for(std::size_t k = 0; k < data.midi_in_ports.size(); ++k)
      {
        if(data.midi_in_ports[k] == port_index)
        {
          v.atom_timePosition_midi.push_back({port_index, &v.midi_atom_ins[k]});
          shared = true;
          break;
        }
      }
      if(!shared)
      {
        v.atom_timePosition_owned_buffers.emplace_back(
            256, data.host.atom_chunk_id, data.host.atom_sequence_id, true);
        v.atom_timePosition_owned.push_back(
            {port_index, &v.atom_timePosition_owned_buffers.back()});
      }
    }
 
    if(lilv_plugin_has_feature(data.effect.plugin.me, data.host.work_schedule)
       && lilv_plugin_has_extension_data(
           data.effect.plugin.me, data.host.work_interface))
    {
      v.worker = static_cast<const LV2_Worker_Interface*>(
          lilv_instance_get_extension_data(v.instance, LV2_WORKER__interface));
    }
 
    for(std::size_t i = 0; i < control_in_size; i++)
      v.fInControls[i] = fParamInit[data.control_in_ports[i]] * fInScale[i];
 
    (void)control_out_size;
    (void)audio_in_size;
    (void)audio_out_size;
  }
 
  void connect_voice_ports(voice& v) noexcept
  {
    auto* inst = v.instance;
    for(std::size_t i = 0; i < data.audio_in_ports.size(); i++)
      lilv_instance_connect_port(inst, data.audio_in_ports[i], v.audio_in_scratch[i].data());
    for(std::size_t i = 0; i < data.audio_out_ports.size(); i++)
      lilv_instance_connect_port(
          inst, data.audio_out_ports[i], v.audio_out_scratch[i].data());
    for(std::size_t i = 0; i < data.control_in_ports.size(); i++)
      lilv_instance_connect_port(inst, data.control_in_ports[i], &v.fInControls[i]);
    for(std::size_t i = 0; i < data.control_out_ports.size(); i++)
      lilv_instance_connect_port(inst, data.control_out_ports[i], &v.fOutControls[i]);
    for(std::size_t i = 0; i < data.cv_ports.size(); i++)
      lilv_instance_connect_port(inst, data.cv_ports[i], v.fCVs[i].data());
    for(std::size_t i = 0; i < data.cv_out_ports.size(); i++)
      lilv_instance_connect_port(inst, data.cv_out_ports[i], v.fCVOuts[i].data());
    for(std::size_t i = 0; i < data.control_other_ports.size(); i++)
      lilv_instance_connect_port(
          inst, data.control_other_ports[i], &v.fOtherControls[i]);
    for(std::size_t i = 0; i < v.midi_atom_ins.size(); i++)
      lilv_instance_connect_port(
          inst, data.midi_in_ports[i], &v.midi_atom_ins[i].buf->atoms);
    for(std::size_t i = 0; i < v.midi_atom_outs.size(); i++)
      lilv_instance_connect_port(
          inst, data.midi_out_ports[i], &v.midi_atom_outs[i].buf->atoms);
    for(std::size_t i = 0; i < v.atom_ins.size(); i++)
      lilv_instance_connect_port(
          inst, data.atom_in_ports[i], &v.atom_ins[i].buf->atoms);
    for(std::size_t i = 0; i < v.atom_outs.size(); i++)
      lilv_instance_connect_port(
          inst, data.atom_out_ports[i], &v.atom_outs[i].buf->atoms);
    for(auto& [port, buf] : v.atom_timePosition_owned)
      lilv_instance_connect_port(inst, port, &buf->buf->atoms);
    for(std::size_t i = 0; i < v.atom_others.size(); i++)
      lilv_instance_connect_port(
          inst, data.atom_other_ports[i], &v.atom_others[i].buf->atoms);
  }
 
  void activate_voice(voice& v) noexcept
  {
    if(v.instance_holder && v.instance && !v.instance_holder->activated)
    {
      lilv_instance_activate(v.instance);
      v.instance_holder->activated = true;
    }
  }
 
  void all_notes_off() noexcept override
  {
    // CC#120 (All Sound Off) + CC#123 (All Notes Off) on every channel of every voice
    if(data.midi_in_ports.empty())
      return;
    const int midi_port_index = data.midi_in_ports[0];
    for(auto& v : voices)
    {
      if(v->message_for_midi_atom_ins.empty())
        continue;
      auto& msg_queue = v->message_for_midi_atom_ins[0];
      for(uint8_t ch = 0; ch < 16; ++ch)
      {
        for(uint8_t cc : {uint8_t(120), uint8_t(123)})
        {
          Message m;
          m.index = uint32_t(midi_port_index);
          m.protocol = data.host.atom_eventTransfer;
          m.body.resize(sizeof(LV2_Atom) + 3);
          auto* atom = reinterpret_cast<LV2_Atom*>(m.body.data());
          atom->type = data.host.midi_event_id;
          atom->size = 3;
          uint8_t* d = m.body.data() + sizeof(LV2_Atom);
          d[0] = uint8_t(0xB0 | ch);
          d[1] = cc;
          d[2] = 0;
          msg_queue.push_back(std::move(m));
        }
      }
    }
  }
 
  [[nodiscard]] std::string label() const noexcept override
  {
    return fmt::format("lv2 ({})", data.effect.plugin.get_name().as_string());
  }
 
  void updateTime(const ossia::token_request& tk, ossia::exec_state_facade st)
  {
    forgeTime(timePositionBuffer.get(), tk, st, tk.speed);
    forgeTime(stoppedPositionBuffer.get(), tk, st, 0.f);
    m_timeForged = true;
  }
 
  void forgeTime(
      uint8_t* buffer, const ossia::token_request& tk, ossia::exec_state_facade st,
      float speed)
  {
    LV2::HostContext& host = data.host;
    auto& forge = host.forge;
    lv2_atom_forge_set_buffer(&forge, buffer, 256);
    LV2_Atom_Forge_Frame frame;
    lv2_atom_forge_object(&forge, &frame, 0, host.time_Position_id);
 
    // The playhead at the first sample of this run. m_transport_frames is
    // only updated once a node has run: it is that of the previous tick.
    lv2_atom_forge_key(&forge, host.time_frame_id);
    lv2_atom_forge_long(
        &forge, tk.speed != 0. ? tk.start_date_to_physical(st.modelToSamples())
                               : this->m_transport_frames);
 
    lv2_atom_forge_key(&forge, host.time_framesPerSecond_id);
    lv2_atom_forge_long(&forge, st.sampleRate());
 
    lv2_atom_forge_key(&forge, host.time_speed_id);
    lv2_atom_forge_float(&forge, speed);
 
    lv2_atom_forge_key(&forge, host.time_bar_id);
    lv2_atom_forge_long(&forge, tk.musical_start_last_bar / 4.);
 
    lv2_atom_forge_key(&forge, host.time_beat_id);
    lv2_atom_forge_double(&forge, tk.musical_start_position);
 
    auto barBeat = float(tk.musical_start_position - tk.musical_start_last_bar);
    lv2_atom_forge_key(&forge, host.time_barBeat_id);
    lv2_atom_forge_float(&forge, barBeat);
 
    lv2_atom_forge_key(&forge, host.time_beatUnit_id);
    lv2_atom_forge_int(&forge, 4);
 
    lv2_atom_forge_key(&forge, host.time_beatsPerBar_id);
    lv2_atom_forge_float(
        &forge, 4 * double(tk.signature.upper) / double(tk.signature.lower));
 
    lv2_atom_forge_key(&forge, host.time_beatsPerMinute_id);
    lv2_atom_forge_float(&forge, tk.tempo);
 
    lv2_atom_forge_pop(&forge, &frame);
  }
 
  // Vec slices by voice (clamped); scalars broadcast. Mirrors faust_mono_fx::set_control.
  static std::optional<float>
  voice_control_value(const ossia::value& val, std::size_t voice_idx) noexcept
  {
    return ossia::apply_nonnull(
        [voice_idx](const auto& v) -> std::optional<float> {
      using T = std::decay_t<decltype(v)>;
      if constexpr(std::is_same_v<T, std::vector<ossia::value>>)
      {
        if(v.empty())
          return std::nullopt;
        const auto& elem = (voice_idx < v.size()) ? v[voice_idx] : v.back();
        return ossia::convert<float>(elem);
      }
      else if constexpr(std::is_same_v<T, ossia::vec2f>)
        return v[std::min<std::size_t>(voice_idx, 1)];
      else if constexpr(std::is_same_v<T, ossia::vec3f>)
        return v[std::min<std::size_t>(voice_idx, 2)];
      else if constexpr(std::is_same_v<T, ossia::vec4f>)
        return v[std::min<std::size_t>(voice_idx, 3)];
      else if constexpr(
          std::is_same_v<T, float> || std::is_same_v<T, int>
          || std::is_same_v<T, bool>)
        return float(v);
      else
        return std::nullopt;
    },
        val.v);
  }
 
  void preProcessVoice(voice& v, std::size_t voice_idx)
  {
    const std::size_t audio_in_size = data.audio_in_ports.size();
    const std::size_t cv_size = data.cv_ports.size();
    const std::size_t midi_in_size = data.midi_in_ports.size();
    const std::size_t atom_in_size = data.atom_in_ports.size();
    const std::size_t control_in_size = data.control_in_ports.size();
 
    int first_midi_idx = (audio_in_size > 0 ? 1 : 0) + cv_size;
    for(std::size_t i = 0; i < v.midi_atom_ins.size(); i++)
    {
      auto& ossia_port
          = this->m_inlets[i + first_midi_idx]->template cast<ossia::midi_port>();
      auto& lv2_port = v.midi_atom_ins[i];
      Iterator it{lv2_port.buf};
 
      // The position first: the sequence is in time order, and the events of
      // this block are at this position.
      if(ossia::any_of(v.atom_timePosition_midi, [&](const auto& t) {
           return t.buffer == &lv2_port;
         }))
        writeTime(it);
 
      for(const Message& msg : v.message_for_midi_atom_ins[i])
      {
        auto* atom = (LV2_Atom*)msg.body.data();
        auto* atom_data = (const uint8_t*)LV2_ATOM_BODY(atom);
        it.write(0, 0, atom->type, atom->size, atom_data);
      }
 
      // Port timestamps are relative to the buffer, the plug-in's to the tick:
      // as the VST3 host does, what falls outside it goes to its nearest end.
      auto& conv = v.midi_2to1[i];
      for(const libremidi::ump& msg : ossia_port.messages)
      {
        const int64_t frame = std::clamp<int64_t>(
            msg.timestamp - m_span.start, 0,
            m_span.samples > 0 ? m_span.samples - 1 : 0);
        conv.convert(
            msg.data, msg.size(), frame,
            [&](const unsigned char* midi1, std::size_t bytes, int64_t) {
          if(bytes > 0)
            it.write(frame, 0, data.host.midi_event_id, bytes, midi1);
          return stdx::error{};
        });
      }
    }
 
    for(auto& [_, buf] : v.atom_timePosition_owned)
    {
      Iterator it{buf->buf};
      writeTime(it);
    }
 
    const auto control_start
        = (audio_in_size > 0 ? 1 : 0) + midi_in_size + atom_in_size + cv_size;
    for(std::size_t i = 0; i < control_in_size; i++)
    {
      auto& in = m_inlets[control_start + i]
                     ->template cast<ossia::value_port>()
                     .get_data();
      if(in.empty())
        continue;
      if(auto new_val = voice_control_value(in.back().value, voice_idx))
        v.fInControls[i] = *new_val * fInScale[i];
    }
 
    (void)atom_in_size;
  }
 
  struct buffer_span
  {
    int64_t start{};
    int64_t samples{};
    int64_t size{};
  } m_span;
 
  template <typename Channel>
  static void readChannel(const Channel& ch, float* dst, const buffer_span& s) noexcept
  {
    const int64_t n = std::clamp<int64_t>(int64_t(ch.size()) - s.start, 0, s.samples);
    for(int64_t j = 0; j < n; j++)
      dst[j] = float(ch[s.start + j]);
    std::fill(dst + n, dst + s.samples, 0.f);
  }
 
  template <typename Channel>
  static void writeChannel(Channel& ch, const float* src, const buffer_span& s)
  {
    if(int64_t(ch.size()) < s.size)
      ch.resize(s.size);
    std::copy_n(src, s.samples, ch.begin() + s.start);
  }
 
  void feedCVInputs(voice& v, std::size_t voice_idx) noexcept
  {
    const std::size_t first_cv = data.audio_in_ports.size() > 0 ? 1 : 0;
    for(std::size_t i = 0; i < v.fCVs.size(); i++)
    {
      auto* buf = v.fCVs[i].data();
      const auto& in = m_inlets[first_cv + i]->template cast<ossia::audio_port>();
      if(const auto chans = in.channels(); chans > 0)
        readChannel(in.channel(voice_idx < chans ? voice_idx : 0), buf, m_span);
      else
        std::fill_n(buf, m_span.samples, 0.f);
    }
  }
 
  void writeCVOutputs(voice& v) noexcept
  {
    const std::size_t first_cv = (data.audio_out_ports.size() > 0 ? 1 : 0)
                                 + data.midi_out_ports.size()
                                 + data.atom_out_ports.size()
                                 + data.control_out_ports.size();
    for(std::size_t i = 0; i < v.fCVOuts.size(); i++)
    {
      auto& out = static_cast<ossia::audio_outlet*>(m_outlets[first_cv + i])->data;
      out.set_channels(1);
      writeChannel(out.channel(0), v.fCVOuts[i].data(), m_span);
    }
  }
 
  void writeTime(Iterator& it) noexcept
  {
    auto write = [&](const uint8_t* buf) {
      const LV2_Atom* atom = (const LV2_Atom*)buf;
      it.write(0, 0, atom->type, atom->size, (const uint8_t*)LV2_ATOM_BODY(atom));
    };
    if(!timePositionBuffer || !m_timeForged)
      return;
    if(m_sendStopped || mustStop)
      write(stoppedPositionBuffer.get());
    if(!mustStop)
      write(timePositionBuffer.get());
  }
 
  void postProcessVoice(voice& v) noexcept
  {
    if(v.worker && v.worker->work_response)
    {
      std::vector<char> vec;
      while(v.worker_datas.try_dequeue(vec))
        v.worker->work_response(v.instance->lv2_handle, vec.size(), vec.data());
    }
    if(v.worker && v.worker->end_run)
      v.worker->end_run(v.instance->lv2_handle);
 
    for(auto& port : v.midi_atom_ins)
      port.buf->reset(true);
    for(auto& port : v.atom_ins)
      port.buf->reset(true);
    for(auto& [_, buf] : v.atom_timePosition_owned)
      buf->buf->reset(true);
    for(auto& port : v.midi_atom_outs)
      port.buf->reset(false);
    for(auto& port : v.atom_outs)
      port.buf->reset(false);
    for(auto& port : v.atom_others)
      port.buf->reset(true);
    for(auto& mqueue : v.message_for_midi_atom_ins)
      mqueue.clear();
  }
 
  // per_channel: inputs broadcast -> voice 0 outputs are canonical
  void surfaceVoiceZeroOutputs(int64_t offset)
  {
    auto& v0 = *voices[0];
    const auto audio_out_size = data.audio_out_ports.size();
    const auto midi_out_size = data.midi_out_ports.size();
    const auto control_out_size = data.control_out_ports.size();
 
    int first_midi_idx = (audio_out_size > 0 ? 1 : 0);
    for(std::size_t i = 0; i < v0.midi_atom_outs.size(); i++)
    {
      auto& ossia_port
          = this->m_outlets[i + first_midi_idx]->template cast<ossia::midi_port>();
      auto& lv2_port = v0.midi_atom_outs[i];
      auto& conv = v0.midi_1to2[i];
 
      lv2_port.buf->for_each_output_event([&](const LV2_Atom_Event& ev) {
        if(ev.body.type == data.host.midi_event_id)
        {
          auto bytes = (const uint8_t*)LV2_ATOM_BODY_CONST(&ev.body);
          conv.convert(
              bytes, ev.body.size, ev.time.frames,
              [&](const uint32_t* ump, int count, int64_t ts) {
            libremidi::ump u;
            std::copy_n(ump, std::min(count, 4), u.data);
            u.timestamp = offset + ts;
            ossia_port.messages.push_back(u);
            return stdx::error{};
          });
        }
        // Other events on a MIDI port are for the plug-in's UI (on_finish
        // forwards them); FIXME also forward them (patch:Set...) to a value
        // outlet.
      });
    }
 
    const auto control_start
        = (audio_out_size > 0 ? 1 : 0) + midi_out_size + data.atom_out_ports.size();
    for(std::size_t i = 0; i < control_out_size; i++)
    {
      auto& out
          = m_outlets[control_start + i]->template cast<ossia::value_port>();
      out.write_value(v0.fOutControls[i] / fOutScale[i], offset);
    }
  }
 
  uint32_t stop_run_samples() const noexcept
  {
    constexpr int64_t fallback = 64;
    const int64_t n = m_span.samples > 0 ? m_span.samples : fallback;
    return uint32_t(std::min<int64_t>(n, int64_t(max_block_size)));
  }
 
  void stop_voices() noexcept
  {
    data.host.current = &data.effect;
    for(auto& vp : voices)
    {
      auto& v = *vp;
      for(std::size_t i = 0; i < v.midi_atom_ins.size(); i++)
      {
        auto& lv2_port = v.midi_atom_ins[i];
        Iterator it{lv2_port.buf};
        if(ossia::any_of(v.atom_timePosition_midi, [&](const auto& t) {
             return t.buffer == &lv2_port;
           }))
          writeTime(it);
        for(const Message& msg : v.message_for_midi_atom_ins[i])
        {
          auto* atom = (LV2_Atom*)msg.body.data();
          it.write(0, 0, atom->type, atom->size, (const uint8_t*)LV2_ATOM_BODY(atom));
        }
      }
      for(auto& [_, buf] : v.atom_timePosition_owned)
      {
        Iterator it{buf->buf};
        writeTime(it);
      }
 
      for(std::size_t i = 0; i < v.audio_in_scratch.size(); i++)
      {
        auto& scratch = v.audio_in_scratch[i];
        std::fill(scratch.begin(), scratch.end(), 0.f);
        lilv_instance_connect_port(v.instance, data.audio_in_ports[i], scratch.data());
      }
      for(std::size_t i = 0; i < v.audio_out_scratch.size(); i++)
        lilv_instance_connect_port(
            v.instance, data.audio_out_ports[i], v.audio_out_scratch[i].data());
 
      // As long as the last tick, not a single frame: plug-ins dividing by
      // (sample_count - 1) to ramp a parameter (SWH's Constant Signal
      // Generator) turn their state to NaN on a run of one frame
      {
        worker_routing_scope ws{data.host, v};
        lilv_instance_run(v.instance, stop_run_samples());
      }
      postProcessVoice(v);
    }
  }
 
  void run(const ossia::token_request& tk, ossia::exec_state_facade st) noexcept override
  {
    // Before the paused check: the tick requested by stop() is empty.
    if(mustStop)
    {
      stop_voices();
      mustStop = false;
      m_sendStopped = true;
      return;
    }
    if(tk.paused())
      return;
 
    data.host.current = &data.effect;
    if(!data.time_Position_ports.empty())
      updateTime(tk, st);
 
    const auto [tick_start, samples] = st.timings(tk);
    const bool samples_valid
        = samples > 0 && std::size_t(samples) <= max_block_size && tick_start >= 0;
    m_span = {
        std::max<int64_t>(tick_start, 0), samples_valid ? samples : 0,
        std::max<int64_t>(st.bufferSize(), tick_start + samples)};
 
    on_start();
    for(std::size_t c = 0; c < voices.size(); ++c)
      preProcessVoice(*voices[c], c);
 
    if(samples_valid)
    {
      for(std::size_t c = 0; c < voices.size(); ++c)
        feedCVInputs(*voices[c], c);
      switch(routing)
      {
        case voice_routing::single:
          runSingle(samples);
          break;
        case voice_routing::per_channel:
          runPerChannel(samples);
          break;
      }
    }
 
    surfaceVoiceZeroOutputs(tk.physical_start(st.modelToSamples()));
    on_finished();
 
    for(auto& v : voices)
      postProcessVoice(*v);
    m_sendStopped = false;
  }
 
  struct worker_routing_scope
  {
    LV2::HostContext& host;
    worker_routing_scope(LV2::HostContext& h, voice& v) noexcept
        : host{h}
    {
      host.current_worker_datas = &v.worker_datas;
    }
    ~worker_routing_scope() noexcept { host.current_worker_datas = nullptr; }
  };
 
  void runSingle(int samples) noexcept
  {
    auto& v = *voices[0];
    const auto audio_ins = data.audio_in_ports.size();
    const auto audio_outs = data.audio_out_ports.size();
 
    if(audio_ins > 0)
    {
      const auto& audio_in = m_inlets[0]->template cast<ossia::audio_port>();
      const auto in_channels = audio_in.channels();
      for(std::size_t i = 0; i < audio_ins; i++)
      {
        auto& scratch = v.audio_in_scratch[i];
        if(in_channels > i)
          readChannel(audio_in.channel(i), scratch.data(), m_span);
        else
          std::fill_n(scratch.data(), samples, 0.0f);
        lilv_instance_connect_port(
            v.instance, data.audio_in_ports[i], scratch.data());
      }
    }
 
    for(std::size_t i = 0; i < audio_outs; i++)
      lilv_instance_connect_port(
          v.instance, data.audio_out_ports[i], v.audio_out_scratch[i].data());
 
    {
      worker_routing_scope ws{data.host, v};
      lilv_instance_run(v.instance, samples);
    }
    writeCVOutputs(v);
 
    if(audio_outs > 0)
    {
      auto& out = static_cast<ossia::audio_outlet*>(m_outlets[0])->data;
      out.set_channels(audio_outs);
      for(std::size_t i = 0; i < audio_outs; i++)
        writeChannel(out.channel(i), v.audio_out_scratch[i].data(), m_span);
    }
  }
 
  // voice c <-> channel c; MIDI/controls broadcast in preProcessVoice
  void runPerChannel(int samples) noexcept
  {
    if(voices.empty())
      return;
 
    const auto* audio_in_inlet
        = m_inlets.empty() ? nullptr : m_inlets[0]->template target<ossia::audio_port>();
    const auto in_channels = audio_in_inlet ? audio_in_inlet->channels() : 0;
 
    // Pure synths drive all voices; otherwise follow input channel count
    const auto requested
        = (audio_in_inlet ? std::max<std::size_t>(in_channels, 1) : voices.size());
    request_voice_count(requested);
 
    const auto active = std::min<std::size_t>(voices.size(), requested);
 
    auto& out = static_cast<ossia::audio_outlet*>(m_outlets[0])->data;
    out.set_channels(active);
 
    for(std::size_t c = 0; c < active; ++c)
    {
      auto& v = *voices[c];
 
      if(audio_in_inlet)
      {
        auto& in_scratch = v.audio_in_scratch[0];
        if(in_channels > c)
          readChannel(audio_in_inlet->channel(c), in_scratch.data(), m_span);
        else
          std::fill_n(in_scratch.data(), samples, 0.0f);
        lilv_instance_connect_port(
            v.instance, data.audio_in_ports[0], in_scratch.data());
      }
 
      auto& out_scratch = v.audio_out_scratch[0];
      lilv_instance_connect_port(
          v.instance, data.audio_out_ports[0], out_scratch.data());
 
      {
        worker_routing_scope ws{data.host, v};
        lilv_instance_run(v.instance, samples);
      }
 
      writeChannel(out.channel(c), out_scratch.data(), m_span);
      if(c == 0)
        writeCVOutputs(v);
    }
  }
};
 
} // namespace LV2