score-plugin-vst3/Vst3/Node.hpp

#pragma once
#include <Process/Dataflow/TimeSignature.hpp>
 
#include <Vst3/EffectModel.hpp>
 
#include <ossia/dataflow/fx_node.hpp>
#include <ossia/dataflow/graph_node.hpp>
#include <ossia/dataflow/port.hpp>
#include <ossia/detail/logger.hpp>
#include <ossia/detail/math.hpp>
#include <ossia/detail/pod_vector.hpp>
#include <ossia/detail/ssize.hpp>
#include <ossia/editor/scenario/time_signature.hpp>
 
#include <libremidi/ump_events.hpp>
#include <pluginterfaces/vst/ivstmidicontrollers.h>
 
#include <public.sdk/source/vst/hosting/eventlist.h>
#include <public.sdk/source/vst/hosting/parameterchanges.h>
 
#include <algorithm>
namespace vst3
{
 
class param_queue final : public Steinberg::Vst::IParamValueQueue
{
public:
  explicit param_queue(Steinberg::Vst::ParamID id)
      : id{id}
  {
  }
  ~param_queue() { }
 
  Steinberg::Vst::ParamID id{};
  ossia::small_vector<std::pair<int32_t, Steinberg::Vst::ParamValue>, 1> data;
  Steinberg::Vst::ParamValue lastValue{};
 
  Steinberg::tresult PLUGIN_API queryInterface(const Steinberg::TUID _iid, void** obj) override
  {
    return Steinberg::kResultOk;
  }
  Steinberg::uint32 PLUGIN_API addRef() override { return 1; }
  Steinberg::uint32 PLUGIN_API release() override { return 1; }
 
  Steinberg::Vst::ParamID PLUGIN_API getParameterId() override { return id; }
  Steinberg::int32 PLUGIN_API getPointCount() override { return data.size(); }
  Steinberg::tresult PLUGIN_API getPoint(
      Steinberg::int32 index, Steinberg::int32& sampleOffset,
      Steinberg::Vst::ParamValue& value) override
  {
    if(ossia::valid_index(index, data))
      std::tie(sampleOffset, value) = data[index];
    else if(index == -1)
    {
      sampleOffset = 0;
      value = lastValue;
    }
 
    return Steinberg::kResultOk;
  }
 
  Steinberg::tresult PLUGIN_API addPoint(
      Steinberg::int32 sampleOffset, Steinberg::Vst::ParamValue value,
      Steinberg::int32& index) override
  {
    index = data.size();
    data.emplace_back(sampleOffset, value);
    return Steinberg::kResultOk;
  }
};
 
class param_changes final : public Steinberg::Vst::IParameterChanges
{
public:
  std::vector<param_queue> queues;
  Steinberg::tresult PLUGIN_API queryInterface(const Steinberg::TUID _iid, void** obj) override
  {
    return Steinberg::kResultOk;
  }
  Steinberg::uint32 PLUGIN_API addRef() override { return 1; }
  Steinberg::uint32 PLUGIN_API release() override { return 1; }
 
  Steinberg::int32 PLUGIN_API getParameterCount() override { return queues.size(); }
 
  param_queue* PLUGIN_API getParameterData(Steinberg::int32 index) override
  {
    return &queues[index];
  }
 
  param_queue* PLUGIN_API addParameterData(
      const Steinberg::Vst::ParamID& id, Steinberg::int32& index /*out*/) override
  {
    index = queues.size();
    queues.emplace_back(id);
    return &queues.back();
  }
};
 
class vst_node_base : public ossia::graph_node
{
public:
  struct PluginHandle
  {
    explicit PluginHandle(const Plugin& p)
        : component{p.component}
        , processor{p.processor}
        , midi_controls{p.midiControls}
    {
      component->addRef();
      processor->addRef();
    }
 
    ~PluginHandle()
    {
      processor->release();
      component->release();
    }
 
    PluginHandle(const PluginHandle&) = delete;
    PluginHandle(PluginHandle&&) = delete;
    PluginHandle& operator=(const PluginHandle&) = delete;
    PluginHandle& operator=(PluginHandle&&) = delete;
 
    Steinberg::Vst::IComponent* component{};
    Steinberg::Vst::IAudioProcessor* processor{};
    MIDIControls midi_controls;
  };
 
  PluginHandle fx;
  // Each element is the amount of channels in a given in/out port
  ossia::small_pod_vector<int, 2> m_audioInputChannels{};
  ossia::small_pod_vector<int, 2> m_audioOutputChannels{};
  int m_totalAudioIns{};
  int m_totalAudioOuts{};
  int m_totalEventIns{};
  int m_totalEventOuts{};
 
protected:
  explicit vst_node_base(const Plugin& ptr)
      : fx{std::move(ptr)}
  {
    this->set_not_fp_safe();
    m_inlets.reserve(10);
    controls.reserve(10);
 
    struct vis
    {
      vst_node_base& self;
      void audioIn(const Steinberg::Vst::BusInfo& bus, int idx)
      {
        self.m_inlets.push_back(new ossia::audio_inlet);
        self.m_audioInputChannels.push_back(bus.channelCount);
        self.m_totalAudioIns += bus.channelCount;
      }
      void eventIn(const Steinberg::Vst::BusInfo& bus, int idx)
      {
        self.m_inlets.push_back(new ossia::midi_inlet);
        self.m_totalEventIns++;
      }
      void audioOut(const Steinberg::Vst::BusInfo& bus, int idx)
      {
        self.m_outlets.push_back(new ossia::audio_outlet);
        self.m_audioOutputChannels.push_back(bus.channelCount);
        self.m_totalAudioOuts += bus.channelCount;
      }
      void eventOut(const Steinberg::Vst::BusInfo& bus, int idx)
      {
        self.m_outlets.push_back(new ossia::midi_outlet);
        self.m_totalEventOuts++;
      }
    };
 
    forEachBus(vis{*this}, *fx.component);
 
    if(auto err = fx.processor->setProcessing(true);
       err != Steinberg::kResultOk && err != Steinberg::kNotImplemented)
    {
      ossia::logger().warn("Couldn't set VST3 processing: {}", err);
    }
 
    m_vstData.processMode = Steinberg::Vst::ProcessModes::kRealtime;
    m_vstData.numInputs = m_audioInputChannels.size();
    m_vstData.numOutputs = m_audioOutputChannels.size();
    m_vstInput.resize(m_audioInputChannels.size());
    m_vstOutput.resize(m_audioOutputChannels.size());
    for(std::size_t i = 0; i < m_audioInputChannels.size(); i++)
    {
      m_vstInput[i].numChannels = m_audioInputChannels[i];
    }
    for(std::size_t i = 0; i < m_audioOutputChannels.size(); i++)
    {
      m_vstOutput[i].numChannels = m_audioOutputChannels[i];
    }
 
    m_vstData.inputs = m_vstInput.data();
    m_vstData.outputs = m_vstOutput.data();
    m_vstData.inputParameterChanges = &m_inputChanges;
    m_vstData.outputParameterChanges = &m_outputChanges;
    m_vstData.inputEvents = &m_inputEvents;
    m_vstData.outputEvents = &m_outputEvents;
    m_vstData.processContext = &m_context;
 
    m_inputEvents.setMaxSize(17 * 128 * m_totalEventIns);
    m_outputEvents.setMaxSize(128 * m_totalEventOuts);
 
    // Give every MIDI-mapped parameter a queue up front.
    //
    // VST3 delivers CC, pitch bend and aftertouch only as parameter changes,
    // and the parameters a plug-in publishes through IMidiMapping are as a rule
    // not the ones exposed as score controls - a JUCE plug-in such as Surge XT
    // answers getMidiControllerAssignment with ids that are not in its
    // parameter list at all. Queues were only ever created by add_control, for
    // exposed controls, so these ids had nowhere to be written and every
    // controller was dropped at the last step even once it had been decoded.
    //
    // Done here rather than on demand because adding a queue allocates, and
    // dispatchMidi runs on the audio thread.
    for(const auto& [key, pid] : fx.midi_controls)
    {
      if(queue_map.find(pid) != queue_map.end())
        continue;
      const auto idx = m_inputChanges.queues.size();
      m_inputChanges.queues.emplace_back(pid);
      queue_map[pid] = idx;
      m_midi_only_queues.push_back(idx);
    }
  }
 
  ~vst_node_base()
  {
    if(auto err = fx.processor->setProcessing(false);
       err != Steinberg::kResultOk && err != Steinberg::kNotImplemented)
    {
      ossia::logger().warn("Couldn't set VST3 processing: {}", err);
    }
  }
 
  struct vst_control
  {
    Steinberg::Vst::ParamID idx{};
    std::size_t queue_idx{};
    ossia::value_port* port{};
  };
 
  ossia::hash_map<Steinberg::Vst::ParamID, std::size_t> queue_map;
 
  ossia::small_vector<std::size_t, 8> m_midi_only_queues;
 
public:
  ossia::small_vector<vst_control, 16> controls;
 
  std::size_t add_control(ossia::value_inlet* inlet, Steinberg::Vst::ParamID id, float v)
  {
    (**inlet).domain = ossia::domain_base<float>{0.f, 1.f};
    (**inlet).type = ossia::val_type::FLOAT;
 
    // The parameter may already own a queue because it is MIDI-mapped too.
    // Reuse it, so a controller and the automation port for the same id do not
    // write to two queues the plug-in then sees as conflicting. Ownership of
    // the per-block clearing passes to setControls().
    if(auto it = queue_map.find(id); it != queue_map.end())
    {
      const auto queue_idx = it->second;
      m_midi_only_queues.erase(
          std::remove(m_midi_only_queues.begin(), m_midi_only_queues.end(), queue_idx),
          m_midi_only_queues.end());
      this->m_inputChanges.queues[queue_idx].lastValue = v;
      controls.push_back({id, queue_idx, inlet->target<ossia::value_port>()});
      root_inputs().push_back(std::move(inlet));
      return queue_idx;
    }
 
    // FIXME this allocates a lot :[
    auto queue_idx = this->m_inputChanges.queues.size();
    this->m_inputChanges.queues.emplace_back(id);
    this->m_inputChanges.queues.back().lastValue = v;
 
    queue_map[id] = queue_idx;
    controls.push_back({id, queue_idx, inlet->target<ossia::value_port>()});
    root_inputs().push_back(std::move(inlet));
    return queue_idx;
  }
 
  // Used when a control is changed from the ui.
  void set_control(std::size_t queue_idx, float value)
  {
    auto& queue = this->m_inputChanges.queues[queue_idx];
    queue.lastValue = value;
    queue.data.clear();
    queue.data.emplace_back(0, value);
  }
 
  void setControls()
  {
    for(vst_control& p : controls)
    {
      const auto& vec = p.port->get_data();
      if(vec.empty())
        continue;
      if(auto t = last(vec).target<float>())
      {
        double value = ossia::clamp<double>((double)*t, 0., 1.);
        auto& queue = m_inputChanges.queues[p.queue_idx];
        queue.data.clear();
        queue.data.emplace_back(0, value);
        queue.lastValue = value;
      }
    }
  }
 
  void dispatchMidi(int64_t tick_start, int64_t samples)
  {
    m_inputEvents.clear();
    m_outputEvents.clear();
 
    for(auto idx : m_midi_only_queues)
      m_inputChanges.queues[idx].data.clear();
 
    int k = 0;
    int audioBusCount = std::ssize(m_audioInputChannels);
    for(int i = audioBusCount; i < audioBusCount + m_totalEventIns; i++)
    {
      dispatchMidi(
          *m_inlets[i]->template target<ossia::midi_port>(), k++, tick_start, samples);
    }
    m_deferred.clear();
    m_vstData.inputEvents
        = (m_inputEvents.getEventCount() > 0) ? &m_inputEvents : nullptr;
    m_vstData.outputEvents = &m_outputEvents;
  }
 
  void stashMidi()
  {
    const int audioBusCount = std::ssize(m_audioInputChannels);
    int k = 0;
    for(int i = audioBusCount; i < audioBusCount + m_totalEventIns; i++, k++)
    {
      for(const libremidi::ump& mess :
          m_inlets[i]->template target<ossia::midi_port>()->messages)
      {
        if(m_deferred.size() >= 1024)
          return;
        m_deferred.push_back({k, mess});
      }
    }
  }
 
  void dispatchMidi(ossia::midi_port& port, int index, int64_t tick_start, int64_t samples)
  {
    // copy midi data
    auto& ip = port.messages;
 
    // Port timestamps are relative to the buffer; the plug-in only sees
    // [tick_start; tick_start + samples[ of it and indexes from 0. Anything
    // held back from an empty tick goes first, at offset 0.
    ossia::small_vector<std::pair<const libremidi::ump*, int64_t>, 16> to_send;
    for(const auto& [bus, mess] : m_deferred)
      if(bus == index)
        to_send.push_back({&mess, 0});
    for(const libremidi::ump& mess : ip)
      to_send.push_back(
          {&mess, std::clamp<int64_t>(
               mess.timestamp - tick_start, 0, samples > 0 ? samples - 1 : 0)});
 
    if(to_send.empty())
      return;
 
    using VstEvent = Steinberg::Vst::Event;
 
    // VST3 has no MIDI CC event: controllers reach the plug-in only as
    // parameter changes, for whichever controllers it published through
    // IMidiMapping (collected into fx.midi_controls). Everything that is not a
    // note goes through here.
    const auto push_midi_control = [this, index](
                                       int channel, int controller, double value,
                                       Steinberg::int32 offset) {
      auto it = this->fx.midi_controls.find({index, channel, controller});
      if(it == this->fx.midi_controls.end())
      {
        // A plug-in that maps a controller globally answers for channel 0
        // only; fall back to it so single-channel plug-ins keep working when
        // the sender uses another channel.
        it = this->fx.midi_controls.find({index, 0, controller});
        if(it == this->fx.midi_controls.end())
          return;
      }
      const auto queue_it = this->queue_map.find(it->second);
      if(queue_it == this->queue_map.end())
        return;
      auto& queue = this->m_inputChanges.queues[queue_it->second];
      queue.data.push_back({offset, value});
      queue.lastValue = value;
    };
 
    VstEvent e;
    e.busIndex = index;
    e.sampleOffset = 0;
    e.ppqPosition = 0; // FIXME
    for(const auto& [mess_ptr, sample_offset] : to_send)
    {
      const libremidi::ump& mess = *mess_ptr;
      if(mess.get_type() != libremidi::midi2::message_type::MIDI_2_CHANNEL)
        continue;
 
      e.sampleOffset = sample_offset;
      switch(libremidi::message_type(mess.get_status_code()))
      {
        case libremidi::message_type::NOTE_ON: {
          auto [channel, note, value] = libremidi::as_01::note_off(mess);
 
          if(value > 0)
          {
            e.type = VstEvent::kNoteOnEvent;
            e.noteOn.channel = channel; // FIXME 0 or 1-based?
            e.noteOn.pitch = note;
            e.noteOn.velocity = value;
            e.noteOn.noteId = -1;
            e.noteOn.tuning = 0.f;
            m_inputEvents.addEvent(e);
          }
          else
          {
            e.type = VstEvent::kNoteOffEvent;
            e.noteOff.channel = mess.get_channel();
            e.noteOff.pitch = note;
            e.noteOff.velocity = 0;
            e.noteOff.noteId = -1;
            e.noteOff.tuning = 0.f;
            m_inputEvents.addEvent(e);
          }
          break;
        }
        case libremidi::message_type::NOTE_OFF: {
          auto [channel, note, value] = libremidi::as_01::note_off(mess);
          e.type = VstEvent::kNoteOffEvent;
          e.noteOff.channel = channel;
          e.noteOff.pitch = note;
          e.noteOff.velocity = value;
          e.noteOff.noteId = -1;
          e.noteOff.tuning = 0.f;
          m_inputEvents.addEvent(e);
          break;
        }
        case libremidi::message_type::POLY_PRESSURE: {
          auto [channel, note, value] = libremidi::as_01::poly_pressure(mess);
          e.type = VstEvent::kPolyPressureEvent;
          e.polyPressure.channel = channel;
          e.polyPressure.pitch = note;
          e.polyPressure.pressure = value;
          e.polyPressure.noteId = -1;
          m_inputEvents.addEvent(e);
          break;
        }
 
        // Control changes were never handled at all, which is what kept every
        // CC out of the plug-ins.
        case libremidi::message_type::CONTROL_CHANGE: {
          const auto cc = libremidi::as_01::control_change(mess);
          push_midi_control(cc.channel, cc.control, cc.value, e.sampleOffset);
          break;
        }
 
        case libremidi::message_type::PITCH_BEND: {
          const auto pb = libremidi::as_01::pitch_bend(mess);
          push_midi_control(
              pb.channel, Steinberg::Vst::kPitchBend, pb.value, e.sampleOffset);
          break;
        }
 
        case libremidi::message_type::AFTERTOUCH: {
          const auto at = libremidi::as_01::aftertouch(mess);
          push_midi_control(
              at.channel, Steinberg::Vst::kAfterTouch, at.value, e.sampleOffset);
          break;
        }
        default:
          break;
      }
    }
  }
 
  void readbackMidi(int64_t tick_start)
  {
    using VstEvent = Steinberg::Vst::Event;
 
    const int audioBusCount = std::ssize(m_audioOutputChannels);
    const int N = m_outputEvents.getEventCount();
 
    for(int i = 0; i < N; i++)
    {
      auto event_p = m_outputEvents.getEventByIndex(i);
      if(!event_p)
        continue;
      VstEvent& e = *event_p;
 
      int bus = e.busIndex;
      auto& port = *m_outlets[bus + audioBusCount]->template target<ossia::midi_port>();
 
      libremidi::ump mess;
 
      switch(e.type)
      {
        case VstEvent::kNoteOnEvent: {
          if(e.noteOn.velocity > 0.f)
            mess = libremidi::from_01::note_on(
                e.noteOn.channel, e.noteOn.pitch, e.noteOn.velocity);
          else
            mess = libremidi::from_01::note_off(e.noteOn.channel, e.noteOn.pitch, 0.);
          break;
        }
        case VstEvent::kNoteOffEvent: {
          mess = libremidi::from_01::note_off(
              e.noteOff.channel, e.noteOff.pitch, e.noteOff.velocity);
          break;
        }
        case VstEvent::kPolyPressureEvent: {
          mess = libremidi::from_01::poly_pressure(
              e.noteOff.channel, e.polyPressure.pitch, e.polyPressure.pressure);
          break;
        }
        default:
          break;
      }
 
      mess.timestamp = tick_start + e.sampleOffset;
      port.messages.push_back(std::move(mess));
    }
  }
 
  auto& preparePort(ossia::audio_port& port, int numChannels, std::size_t samples)
  {
    port.set_channels(numChannels);
 
    for(auto& i : port)
      i.resize(samples);
    return port.get();
  }
 
  void setupTimeInfo(const ossia::token_request& tk, ossia::exec_state_facade st)
  {
    using namespace Steinberg::Vst;
    using F = ProcessContext;
    Steinberg::Vst::ProcessContext& time_info = this->m_context;
    time_info.sampleRate = st.sampleRate();
 
    time_info.projectTimeSamples = this->m_transport_frames;
 
    time_info.systemTime = st.currentDate() - st.startDate();
    time_info.continousTimeSamples = this->m_processed_frames; // TODO
 
    time_info.projectTimeMusic = tk.musical_start_position;
    time_info.barPositionMusic = tk.musical_start_last_bar;
    time_info.cycleStartMusic = 0.;
    time_info.cycleEndMusic = 0.;
 
    time_info.tempo = tk.tempo;
    time_info.timeSigNumerator = tk.signature.upper;
    time_info.timeSigDenominator = tk.signature.lower;
 
    // time_info.chord = ....;
 
    time_info.smpteOffsetSubframes = 0;
    time_info.frameRate = {};
    time_info.samplesToNextClock = 0;
    time_info.state = F::kPlaying | F::kSystemTimeValid | F::kContTimeValid
                      | F::kProjectTimeMusicValid | F::kBarPositionValid | F::kTempoValid
                      | F::kTimeSigValid;
  }
 
  Steinberg::Vst::ProcessData m_vstData;
  ossia::small_vector<Steinberg::Vst::AudioBusBuffers, 1> m_vstInput;
  ossia::small_vector<Steinberg::Vst::AudioBusBuffers, 1> m_vstOutput;
 
  Steinberg::Vst::ProcessContext m_context;
  param_changes m_inputChanges;
  param_changes m_outputChanges;
  Steinberg::Vst::EventList m_inputEvents;
  Steinberg::Vst::EventList m_outputEvents;
 
  ossia::small_vector<std::pair<int, libremidi::ump>, 8> m_deferred;
};
 
template <bool UseDouble>
class vst_node final : public vst_node_base
{
public:
  vst_node(Plugin dat, int sampleRate)
      : vst_node_base{std::move(dat)}
  {
    if constexpr(UseDouble)
      m_vstData.symbolicSampleSize = Steinberg::Vst::kSample64;
    else
      m_vstData.symbolicSampleSize = Steinberg::Vst::kSample32;
  }
 
  ~vst_node() { }
 
  std::string label() const noexcept override { return "VST3"; }
 
  void all_notes_off(int bus) noexcept
  {
    bool ok = false;
    // Panic goes to channel 0's mapping: it is a global request, and a
    // per-channel sweep would write the same parameter sixteen times.
    if(auto it
       = this->fx.midi_controls.find({bus, 0, Steinberg::Vst::kCtrlAllNotesOff});
       it != this->fx.midi_controls.end())
    {
      Steinberg::Vst::ParamID pid = it->second;
      if(auto queue_it = this->queue_map.find(pid); queue_it != this->queue_map.end())
      {
        auto& queue = this->m_inputChanges.queues[queue_it->second];
        queue.data.push_back({0, 1.});
        queue.lastValue = 1.;
        ok = true;
      }
    }
 
    if(auto it
       = this->fx.midi_controls.find({bus, 0, Steinberg::Vst::kCtrlAllSoundsOff});
       it != this->fx.midi_controls.end())
    {
      Steinberg::Vst::ParamID pid = it->second;
      if(auto queue_it = this->queue_map.find(pid); queue_it != this->queue_map.end())
      {
        auto& queue = this->m_inputChanges.queues[queue_it->second];
        queue.data.push_back({0, 1.});
        queue.lastValue = 1.;
        ok = true;
      }
    }
 
    if(!ok)
    {
      // Send manual note off events
      for(int k = 0; k <= 16; k++)
        for(int i = 0; i <= 127; i++)
        {
          using VstEvent = Steinberg::Vst::Event;
          VstEvent e;
          e.busIndex = bus;
          e.sampleOffset = 0;
          e.ppqPosition = 0; // FIXME
          e.sampleOffset = 0;
          e.type = VstEvent::kNoteOffEvent;
          e.noteOff.channel = k;
          e.noteOff.pitch = i;
          e.noteOff.velocity = 0;
          e.noteOff.noteId = -1;
          e.noteOff.tuning = 0.f;
          m_inputEvents.addEvent(e);
        }
    }
  }
 
  void all_notes_off() noexcept override
  {
    if(m_totalEventIns == 0)
      return;
 
    m_inputEvents.clear();
 
    // Put messages into each MIDI in's event queues
    {
      for(int i = 0; i < m_totalEventIns; i++)
      {
        all_notes_off(i++);
      }
    }
 
    // Run a process cycle
    {
      constexpr int samples = 64;
      Steinberg::Vst::ProcessData dat;
      memcpy(&dat, &m_vstData, sizeof(m_vstData));
      dat.inputEvents = &m_inputEvents;
      dat.numSamples = samples;
 
      {
        double** input{};
        double** output{};
 
        // Copy inputs
        if(m_totalAudioIns > 0)
        {
          input = (double**)alloca(sizeof(double*) * m_totalAudioIns);
 
          for(int k = 0; k < m_totalAudioIns; k++)
          {
            input[k] = (double*)alloca(sizeof(double) * samples);
            memset(input[k], 0, sizeof(double) * samples);
          }
 
          for(std::size_t i = 0; i < m_audioInputChannels.size(); i++)
          {
            Steinberg::Vst::AudioBusBuffers& vst_in = dat.inputs[i];
            vst_in.channelBuffers64 = input;
            vst_in.silenceFlags = ~0ULL;
          }
        }
 
        // Prepare outputs
        if(m_totalAudioOuts > 0)
        {
          output = (double**)alloca(sizeof(double*) * m_totalAudioOuts);
          for(int k = 0; k < m_totalAudioOuts; k++)
          {
            output[k] = (double*)alloca(sizeof(double) * samples);
            memset(output[k], 0, sizeof(double) * samples);
          }
 
          for(std::size_t i = 0; i < m_audioOutputChannels.size(); i++)
          {
            Steinberg::Vst::AudioBusBuffers& vst_out = dat.outputs[i];
            vst_out.channelBuffers64 = output;
            vst_out.silenceFlags = ~0ULL;
          }
        }
 
        fx.processor->process(dat);
      }
    }
  }
 
  void run(const ossia::token_request& tk, ossia::exec_state_facade st) noexcept override
  {
    if(!muted() && !tk.paused())
    {
      const auto [tick_start, samples] = st.timings(tk);
      if(samples <= 0)
      {
        // Never call a plug-in with an empty block, but do not lose what the
        // tick carried: it is delivered at the top of the next real one.
        this->stashMidi();
        return;
      }
 
      this->setControls();
      this->setupTimeInfo(tk, st);
 
      this->dispatchMidi(tick_start, samples);
 
      if constexpr(UseDouble)
      {
        processDouble(tick_start, samples, st.bufferSize());
      }
      else
      {
        processFloat(tick_start, samples, st.bufferSize());
      }
 
      this->readbackMidi(tick_start);
    }
  }
 
  void processFloat(int64_t tick_start, std::size_t samples, int bufferSize)
  {
    // In the float case we have temporary buffers for conversion
    if constexpr(!UseDouble)
    {
      // Prepare buffers
      if(m_totalAudioIns > 0 || m_totalAudioOuts > 0)
      {
        float_v.resize(std::max(m_totalAudioIns, m_totalAudioOuts));
        for(auto& v : float_v)
          v.resize(samples);
 
        float** input{};
        float** output{};
 
        // Copy inputs
        if(m_totalAudioIns > 0)
        {
          input = (float**)alloca(sizeof(float*) * m_totalAudioIns);
          int channel_k = 0;
          int float_k = 0;
 
          for(std::size_t i = 0; i < m_audioInputChannels.size(); i++)
          {
            const int numChannels = m_audioInputChannels[i];
            auto& port = *m_inlets[i]->template target<ossia::audio_port>();
            auto& ip = preparePort(port, numChannels, bufferSize);
 
            Steinberg::Vst::AudioBusBuffers& vst_in = m_vstInput[i];
            vst_in.channelBuffers32 = input + channel_k;
            vst_in.silenceFlags = 0;
 
            for(int k = 0; k < numChannels; k++)
            {
              const std::size_t avail = ip[k].size() > std::size_t(tick_start)
                                            ? ip[k].size() - std::size_t(tick_start)
                                            : 0u;
              std::copy_n(
                  ip[k].data() + tick_start, std::min(samples, avail),
                  float_v[float_k].data());
              input[channel_k] = float_v[float_k].data();
              channel_k++;
              float_k++;
            }
          }
        }
 
        // Prepare outputs
        if(m_totalAudioOuts > 0)
        {
          // copy audio data
          output = (float**)alloca(sizeof(float*) * m_totalAudioOuts);
 
          int channel_k = 0;
          int float_k = 0;
          for(std::size_t i = 0; i < m_audioOutputChannels.size(); i++)
          {
            const int numChannels = m_audioOutputChannels[i];
            auto& port = *m_outlets[i]->template target<ossia::audio_port>();
            preparePort(port, numChannels, bufferSize);
 
            Steinberg::Vst::AudioBusBuffers& vst_out = m_vstOutput[i];
            vst_out.channelBuffers32 = output + channel_k;
            vst_out.silenceFlags = 0;
            for(int k = 0; k < numChannels; k++)
            {
              output[channel_k] = float_v[float_k].data();
              channel_k++;
              float_k++;
            }
          }
        }
      }
 
      // Run the process
      {
        m_vstData.numSamples = samples;
 
        fx.processor->process(m_vstData);
      }
 
      // Copy the float outputs to the audio outlet buffer
      if(m_totalAudioOuts > 0)
      {
        int float_k = 0;
        for(std::size_t i = 0; i < m_audioOutputChannels.size(); i++)
        {
          const int numChannels = m_audioOutputChannels[i];
          ossia::audio_port& port = *m_outlets[i]->template target<ossia::audio_port>();
          for(int k = 0; k < numChannels; k++)
          {
            auto& audio_out = port.channel(k);
            std::copy_n(
                float_v[float_k].data(), samples, audio_out.data() + tick_start);
            float_k++;
          }
        }
      }
    }
  }
 
  void processDouble(int64_t tick_start, std::size_t samples, int bufferSize)
  {
    // In the double case we use directly the buffers that are part of the
    // input & output ports
    if constexpr(UseDouble)
    {
      double** input{};
      double** output{};
 
      // Copy inputs
      if(m_totalAudioIns > 0)
      {
        input = (double**)alloca(sizeof(double*) * m_totalAudioIns);
 
        int channel_k = 0;
        for(std::size_t i = 0; i < m_audioInputChannels.size(); i++)
        {
          const int numChannels = m_audioInputChannels[i];
          auto& port = *m_inlets[i]->template target<ossia::audio_port>();
          auto& ip = preparePort(port, numChannels, bufferSize);
 
          Steinberg::Vst::AudioBusBuffers& vst_in = m_vstInput[i];
          vst_in.channelBuffers64 = input + channel_k;
          vst_in.silenceFlags = 0;
          for(int k = 0; k < numChannels; k++)
          {
            input[channel_k++] = ip[k].data() + tick_start;
          }
        }
      }
 
      // Prepare outputs
      if(m_totalAudioOuts > 0)
      {
        output = (double**)alloca(sizeof(double*) * m_totalAudioOuts);
        int channel_k = 0;
        for(std::size_t i = 0; i < m_audioOutputChannels.size(); i++)
        {
          const int numChannels = m_audioOutputChannels[i];
          auto& port = *m_outlets[i]->template target<ossia::audio_port>();
          auto& op = preparePort(port, numChannels, bufferSize);
 
          Steinberg::Vst::AudioBusBuffers& vst_out = m_vstOutput[i];
          vst_out.channelBuffers64 = output + channel_k;
          vst_out.silenceFlags = 0;
          for(int k = 0; k < numChannels; k++)
          {
            output[channel_k++] = op[k].data() + tick_start;
          }
        }
      }
 
      // Run process
      {
        m_vstData.numSamples = samples;
 
        fx.processor->process(m_vstData);
      }
    }
  }
 
  struct dummy_t
  {
  };
  std::conditional_t<!UseDouble, std::vector<ossia::float_vector>, dummy_t> float_v;
};
 
template <bool b1, typename... Args>
auto make_vst_fx(Args&... args)
{
  return ossia::make_node<vst_node<b1>>(args...);
}
}