dataflow/nodes/midi.hpp

#pragma once
#include <ossia/dataflow/graph_node.hpp>
#include <ossia/dataflow/node_process.hpp>
#include <ossia/dataflow/port.hpp>
#include <ossia/detail/flat_multiset.hpp>
 
#include <libremidi/ump_events.hpp>
 
#include <algorithm>
 
namespace ossia::nodes
{
 
using midi_size_t = uint8_t;
struct note_data
{
  time_value start{};
  time_value duration{};
 
  midi_size_t pitch{};
  midi_size_t velocity{};
};
 
inline bool is_note_off(const libremidi::ump& m) noexcept
{
  return (m.get_status_code() & 0xF0) == 0x80;
}
 
inline time_value note_end(const note_data& n) noexcept
{
  return n.start + n.duration;
}
 
struct note_comparator
{
  using is_transparent = std::true_type;
  bool operator()(const note_data& lhs, const note_data& rhs) const
  {
    return lhs.start < rhs.start;
  }
  bool operator()(const note_data& lhs, int64_t rhs) const
  {
    return lhs.start.impl < rhs;
  }
};

struct note_end_comparator
{
  using is_transparent = std::true_type;
  bool operator()(const note_data& lhs, const note_data& rhs) const
  {
    return note_end(lhs) < note_end(rhs);
  }
  bool operator()(const note_data& lhs, int64_t rhs) const
  {
    return note_end(lhs).impl < rhs;
  }
};
 
class midi final : public ossia::nonowning_graph_node
{
  ossia::midi_outlet midi_out;
 
public:
  using note_set = ossia::flat_multiset<note_data, note_comparator>;
  using note_end_set = ossia::flat_multiset<note_data, note_end_comparator>;
  explicit midi(int64_t notes)
  {
    m_outlets.push_back(&midi_out);
    int64_t to_reserve = std::max(notes * 1.1, 128.);
    m_notes.reserve(to_reserve);
    m_orig_notes.reserve(to_reserve);
    m_by_end.reserve(to_reserve);
    m_playing_notes.reserve(to_reserve);
    m_to_stop.reserve(64);
    m_to_resume.reserve(64);
  }
 
  ~midi() override = default;
 
  std::string label() const noexcept override { return "midi"; }
 
  void set_channel(int c) { m_channel = c - 1; }
 
  void add_note(note_data nd)
  {
    m_orig_notes.insert(nd);
    m_by_end.insert(nd);
    // The playing scan takes start >= t.prev_date, and m_prev_date is where the
    // next tick starts: a note landing exactly there is still to be played.
    // With a strict comparison it was dropped, and every note at date 0 with it.
    if(nd.start >= m_prev_date)
    {
      m_notes.insert(nd);
    }
  }
 
  // The comparators only order on one date: erasing by key would remove every
  // note sharing it, and find() could return a note of another pitch.
  template <typename Set>
  static bool erase_exact(Set& set, const note_data& nd)
  {
    auto [first, last] = set.equal_range(nd);
    for(auto it = first; it != last; ++it)
    {
      if(it->pitch == nd.pitch)
      {
        set.erase(it);
        return true;
      }
    }
    return false;
  }
 
  template <typename Set>
  static bool contains_exact(const Set& set, const note_data& nd)
  {
    auto [first, last] = set.equal_range(nd);
    for(auto it = first; it != last; ++it)
      if(it->pitch == nd.pitch)
        return true;
    return false;
  }
 
  void remove_note(note_data nd)
  {
    erase_exact(m_orig_notes, nd);
    erase_exact(m_by_end, nd);
    erase_exact(m_notes, nd);
    if(erase_exact(m_playing_notes, nd))
      m_to_stop.insert(nd);
  }
 
  void replace_notes(note_set&& notes)
  {
    for(auto& note : m_playing_notes)
      m_to_stop.insert(note);
    m_playing_notes.clear();
 
    m_to_resume.clear();
 
    using namespace std;
    swap(m_orig_notes, notes);
    rebuild_end_index();
    m_notes.clear();
 
    auto start_it = m_orig_notes.lower_bound(m_prev_date.impl);
    if(start_it != m_orig_notes.end())
    {
      m_notes.tree().get_sequence_ref().assign(start_it, m_orig_notes.end());
    }
  }
 
  void transport(ossia::time_value date)
  {
    requestTransport = true;
    m_transport_date = date;
  }
 
  void transport_impl(ossia::time_value date)
  {
    // Whatever was playing has to be released: the playhead no longer follows
    // from it.
    m_to_stop.insert(m_playing_notes.begin(), m_playing_notes.end());
    m_playing_notes.clear();
    m_to_resume.clear();
 
    // Everything starting at or after the new position is to be played again,
    // and a note the position lands inside of is resumed from its middle -
    // the note-on scan can never pick those up, since it only matches notes
    // starting at or after the beginning of a tick.
    m_notes.clear();
    for(const note_data& n : m_orig_notes)
    {
      if(n.start >= date)
        m_notes.insert(n);
      else if((n.start + n.duration) > date)
        m_to_resume.insert(n);
    }
 
    m_prev_date = date;
  }
 
  void update_note(note_data oldNote, note_data newNote)
  {
    // OPTIMIZEME
    remove_note(oldNote);
    add_note(newNote);
  }
 
  void set_notes(note_set&& notes)
  {
    m_notes = std::move(notes);
    m_orig_notes = m_notes;
    rebuild_end_index();
 
    auto max_it = m_notes.lower_bound({m_prev_date});
    if(max_it != m_notes.begin()) // TODO handle the begin case correctly
      m_notes.erase(m_notes.begin(), max_it);
  }
 
  bool mustStop{};
  bool requestTransport{};
 
private:
  void rebuild_end_index()
  {
    m_by_end.clear();
    m_by_end.insert(m_orig_notes.begin(), m_orig_notes.end());
  }

  void resume_notes(ossia::midi_port& mp, int64_t tick_start)
  {
    for(const note_data& note : m_to_resume)
    {
      mp.messages.push_back(
          libremidi::from_midi1::note_on(m_channel, note.pitch, note.velocity));
      mp.messages.back().timestamp = tick_start;
      m_playing_notes.insert(note);
    }
    m_to_resume.clear();
  }

  void rewind(
      const ossia::token_request& t, ossia::midi_port& mp, double samplesratio,
      int64_t tick_start)
  {
    // physical_write_duration divides an absolute duration by a signed speed,
    // so it comes out negative when rewinding.
    const auto tick_end
        = tick_start + std::abs(t.physical_write_duration(samplesratio));
    const auto stamp = [&](time_value at) {
      return std::clamp(
          t.to_physical_time_in_tick(at, samplesratio), tick_start,
          std::max(tick_start, tick_end - 1));
    };
 
    // Enter the notes whose end the playhead went back over, from their tail.
    // ]date; prev_date] : an end landing exactly on prev_date was not sounding
    // there, the interval of a note being [start; end[.
    {
      const note_data lo{t.date, 0_tv};
      const note_data hi{t.prev_date, 0_tv};
      for(auto it = m_by_end.upper_bound(lo), last = m_by_end.upper_bound(hi);
          it != last; ++it)
      {
        if(contains_exact(m_playing_notes, *it))
          continue;
 
        mp.messages.push_back(
            libremidi::from_midi1::note_on(m_channel, it->pitch, it->velocity));
        mp.messages.back().timestamp = stamp(note_end(*it));
 
        m_playing_notes.insert(*it);
        erase_exact(m_notes, *it);
      }
    }
 
    // Leave the ones whose start it went back over. After entering, so that a
    // note falling entirely inside this tick is played then released, the same
    // way the forward pass handles a note shorter than its tick.
    for(auto it = m_playing_notes.begin(); it != m_playing_notes.end();)
    {
      if(it->start > t.date)
      {
        mp.messages.push_back(
            libremidi::from_midi1::note_off(m_channel, it->pitch, 0));
        mp.messages.back().timestamp = stamp(it->start);
        it = m_playing_notes.erase(it);
      }
      else
      {
        ++it;
      }
    }
 
    // Everything the playhead went back over the start of has to be playable
    // again. Exactly once: m_notes is a multiset, and a note that had not been
    // played yet is still in it.
    const auto first = m_orig_notes.upper_bound({t.date});
    const auto last = m_orig_notes.upper_bound({t.prev_date});
    for(auto it = first; it != last; ++it)
    {
      erase_exact(m_notes, *it);
      m_notes.insert(*it);
    }
  }

  static int64_t stamp_in_tick(
      const ossia::token_request& t, time_value at, double samplesratio,
      int64_t tick_start) noexcept
  {
    const auto tick_end
        = tick_start + std::abs(t.physical_write_duration(samplesratio));
    return std::clamp(
        t.to_physical_time_in_tick(at, samplesratio), tick_start,
        std::max(tick_start, tick_end - 1));
  }

  void stop_finished_notes(
      const ossia::token_request& t, ossia::midi_port& mp, double samplesratio,
      int64_t tick_start)
  {
    for(auto it = m_playing_notes.begin(); it != m_playing_notes.end();)
    {
      const note_data& note = *it;
      const auto end_time = note.start + note.duration;
 
      if(end_time < t.date)
      {
        mp.messages.push_back(libremidi::from_midi1::note_off(m_channel, note.pitch, 0));
        mp.messages.back().timestamp
            = stamp_in_tick(t, end_time, samplesratio, tick_start);
 
        it = m_playing_notes.erase(it);
      }
      else
      {
        ++it;
      }
    }
  }
 
  void run(const ossia::token_request& t, ossia::exec_state_facade e) noexcept override
  {
    ossia::midi_port& mp = *midi_out;
 
    struct scope_guard
    {
      midi& self;
      const ossia::token_request& t;
      ossia::midi_port& mp;
      std::size_t first_message;
      ~scope_guard()
      {
        // Consumers (VST3 event lists, MIDI outputs...) expect events in
        // chronological order, and a note-off must win over a note-on sharing
        // its timestamp, else back-to-back notes on the same pitch cancel out.
        auto begin = mp.messages.begin() + first_message;
        std::stable_sort(begin, mp.messages.end(), [](const auto& lhs, const auto& rhs) {
          if(lhs.timestamp != rhs.timestamp)
            return lhs.timestamp < rhs.timestamp;
          return is_note_off(lhs) && !is_note_off(rhs);
        });
 
        self.m_prev_date = t.date;
 
        if(self.requestTransport)
        {
          self.transport_impl(self.m_transport_date);
          self.requestTransport = false;
        }
      }
    } guard{*this, t, mp, mp.messages.size()};
 
    const auto samplesratio = e.modelToSamples();
    const auto tick_start = t.physical_start(samplesratio);
 
    if(t.end_discontinuous)
    {
      auto& mess = mp.messages;
      for(auto note : m_playing_notes)
      {
        mess.push_back(libremidi::from_midi1::note_off(m_channel, note.pitch, 0));
        mess.back().timestamp = tick_start;
      }
      for(auto note : m_to_stop)
      {
        mess.push_back(libremidi::from_midi1::note_off(m_channel, note.pitch, 0));
        mess.back().timestamp = tick_start;
      }
      m_playing_notes.clear();
      m_to_stop.clear();
      return;
    }
 
    for(const note_data& note : m_to_stop)
    {
      mp.messages.push_back(libremidi::from_midi1::note_off(m_channel, note.pitch, 0));
      mp.messages.back().timestamp = tick_start;
    }
    m_to_stop.clear();
 
    if(mustStop)
    {
      for(auto& note : m_playing_notes)
      {
        mp.messages.push_back(libremidi::from_midi1::note_off(m_channel, note.pitch, 0));
        mp.messages.back().timestamp = tick_start;
      }
 
      m_notes = m_orig_notes;
      m_playing_notes.clear();
      m_to_resume.clear();
 
      mustStop = false;
    }
    else
    {
      // Not when rewinding: everything may well have been played already, and
      // going back over it is exactly what has to bring it back.
      if(!t.backward() && m_notes.empty() && m_playing_notes.empty()
         && m_to_resume.empty())
        return;
 
      resume_notes(mp, tick_start);
 
      if(t.backward())
      {
        rewind(t, mp, samplesratio, tick_start);
      }
      else if(t.forward())
      {
        stop_finished_notes(t, mp, samplesratio, tick_start);
 
        // Look for all the messages
        auto max_it = m_notes.lower_bound({t.date});
        for(auto it = m_notes.begin(); it < max_it;)
        {
          note_data& note = const_cast<note_data&>(*it);
          auto start_time = note.start;
          if(start_time >= t.prev_date && start_time < t.date)
          {
            // Send note_on
            mp.messages.push_back(
                libremidi::from_midi1::note_on(m_channel, note.pitch, note.velocity));
            mp.messages.back().timestamp
                = stamp_in_tick(t, start_time, samplesratio, tick_start);
 
            m_playing_notes.insert(note);
            it = m_notes.erase(it);
            max_it = std::lower_bound(
                it, m_notes.end(), t.date.impl + 1, note_comparator{});
          }
          else
          {
            ++it;
          }
        }
 
        // Notes short enough to begin and end inside this tick were not in
        // m_playing_notes when the first pass ran: stop them here.
        stop_finished_notes(t, mp, samplesratio, tick_start);
      }
    }
  }
 
  note_set m_notes;
  note_set m_orig_notes;
  note_set m_playing_notes;
  note_set m_to_stop;
  note_set m_to_resume;
  note_end_set m_by_end;
  time_value m_prev_date{};
  time_value m_transport_date{};
 
  int m_channel{};
};
 
class midi_node_process final : public ossia::node_process
{
public:
  using ossia::node_process::node_process;
 
  void transport_impl(ossia::time_value date) override
  {
    midi& n = *static_cast<midi*>(node.get());
    n.transport(date);
  }
 
  void stop() override
  {
    midi& n = *static_cast<midi*>(node.get());
    n.request(ossia::token_request{});
    n.mustStop = true;
  }
};
}