ValueLoop.hpp

#pragma once
#include <Fx/Looper/PassStack.hpp>
 
#include <ossia/network/value/value.hpp>
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <utility>
 
namespace Nodes::Looper
{
class value_slot
{
public:
  value_slot() noexcept = default;
  value_slot(const value_slot& o) { m_value = o.m_value; }
  value_slot(value_slot&& o) noexcept { m_value = std::move(o.m_value); }
  value_slot& operator=(const value_slot& o)
  {
    if(this != &o)
      m_value = o.m_value;
    return *this;
  }
  value_slot& operator=(value_slot&& o) noexcept
  {
    if(this != &o)
      m_value = std::move(o.m_value);
    return *this;
  }
  ~value_slot() = default;
 
  void set(const ossia::value& v) { m_value = v; }
  void set(ossia::value&& v) noexcept { m_value = std::move(v); }
  void reset() noexcept { m_value = ossia::value{}; }
 
  const ossia::value& get() const noexcept { return m_value; }
  bool empty() const noexcept { return !m_value.valid(); }
  bool impulse() const noexcept { return m_value.get_type() == ossia::val_type::IMPULSE; }
 
  static bool same(const ossia::value& a, const ossia::value& b) noexcept
  {
    return a.get_type() == b.get_type() && a == b;
  }
  bool same(const ossia::value& o) const noexcept { return same(m_value, o); }
  bool same(const value_slot& o) const noexcept { return same(m_value, o.m_value); }
 
private:
  ossia::value m_value;
};
 
struct value_event
{
  int64_t pos;
  int64_t written;
  value_slot value;
  uint32_t serial;
  uint16_t key;
  bool impulse;
  uint8_t pass;
  uint64_t replaced_by;
  uint8_t merged;
};
 
struct value_stretch
{
  int64_t from;
  int64_t span;
  uint32_t serial;
  uint16_t key;
  uint8_t pass;
  uint64_t replaced_by;
  uint8_t merged;
};
 
struct value_loop : tagged_pass_stack<value_loop, tagged_pass, 32>
{
  static constexpr int max_events = 8192;
  static constexpr int max_stretches = 512;
  static constexpr int max_touched = 16;
 
  std::array<value_event, max_events> events{};
  std::array<value_stretch, max_stretches> stretches{};
  int event_count{};
  int stretch_count{};
  bool full{};
  uint32_t next_serial{};
 
  struct touch
  {
    uint16_t key;
    int64_t first;
    int64_t at;
    bool backwards;
    int stretch;
  };
  std::array<touch, max_touched> touches{};
  int touch_count{};
  uint32_t serial{};
  bool whole{};
 
  // tagged_pass_stack's hooks: the values and the stretches are the
  // material.
  void clear_material() noexcept
  {
    for(int i = 0; i < event_count; i++)
      events[i].value.reset();
    event_count = 0;
    stretch_count = 0;
    full = false;
    next_serial = 0;
  }
  void pass_state_begun() noexcept
  {
    touch_count = 0;
    serial = next_serial++;
    whole = false;
  }
 
  void begin_recording() noexcept
  {
    tagged_pass_stack::begin_recording();
    whole = true;
  }
  template <typename F>
  void for_each_material(F&& f) noexcept
  {
    for(int i = 0; i < event_count; i++)
      f(events[i]);
    for(int i = 0; i < stretch_count; i++)
      f(stretches[i]);
  }
  template <typename F>
  void remove_material(F&& gone) noexcept
  {
    remove_events(gone);
    stretch_count = int(
        std::remove_if(stretches.begin(), stretches.begin() + stretch_count, gone)
        - stretches.begin());
    for(int i = 0; i < touch_count; i++)
      touches[i].stretch = find_stretch(touches[i].key);
  }
 
  template <typename F>
  void remove_events(F&& gone) noexcept
  {
    int out = 0;
    for(int i = 0; i < event_count; i++)
    {
      if(gone(events[i]))
        continue;
      if(out != i)
        events[out] = std::move(events[i]);
      out++;
    }
    for(int i = out; i < event_count; i++)
      events[i].value.reset();
    if(out != event_count)
      edits++;
    event_count = out;
  }
 
  template <typename T>
  bool heard(const T& e, bool own_mute = true) const noexcept
  {
    return e.pass < count && !replaced(e.replaced_by, e.pass, false)
           && !(own_mute && layers[e.pass].muted);
  }
 
  int find_stretch(uint16_t key) const noexcept
  {
    if(!taking || count == 0)
      return -1;
    for(int i = stretch_count - 1; i >= 0; i--)
      if(stretches[i].key == key && stretches[i].serial == serial
         && stretches[i].pass == count - 1)
        return i;
    return -1;
  }
 
  const touch* touched(uint16_t key) const noexcept
  {
    for(int i = 0; i < touch_count; i++)
      if(touches[i].key == key)
        return &touches[i];
    return nullptr;
  }
 
  void touch_key(uint16_t key, int64_t pos, int64_t at, bool backwards) noexcept
  {
    if(touched(key) || touch_count >= max_touched || stretch_count >= max_stretches)
      return;
    auto& s = stretches[stretch_count];
    s = value_stretch{
        .from = pos,
        .span = 0,
        .serial = serial,
        .key = key,
        .pass = uint8_t(count - 1),
        .replaced_by = 0,
        .merged = 0};
    touches[touch_count++] = touch{key, pos, at, backwards, stretch_count};
    stretch_count++;
    update_open_stretches();
  }
 
  void update_open_stretches() noexcept
  {
    for(int i = 0; i < touch_count; i++)
    {
      const auto& t = touches[i];
      if(t.stretch < 0)
        continue;
      auto& s = stretches[t.stretch];
      const int64_t span = std::max<int64_t>(0, length - t.at);
      set_stretch(s, t, pass_written >= length || whole ? length : span);
    }
  }
 
  void set_stretch(value_stretch& s, const touch& t, int64_t span) noexcept
  {
    int64_t from = t.backwards ? t.first - span : t.first;
    if(length > 0)
    {
      from %= length;
      if(from < 0)
        from += length;
    }
    if(s.from != from || s.span != span)
      edits++;
    s.from = from;
    s.span = span;
  }
 
  void end_pass() noexcept
  {
    if(!taking)
      return;
    edits++;
    for(int i = 0; i < touch_count; i++)
    {
      const auto& t = touches[i];
      if(t.stretch < 0)
        continue;
      auto& s = stretches[t.stretch];
      const int64_t span = whole ? length : pass_written - t.at;
      set_stretch(s, t, std::min(span, length));
    }
    // A stretch the pass did not get to is none.
    remove_material([](const auto& e) {
      if constexpr(requires { e.span; })
        return e.span <= 0;
      else
        return false;
    });
    touch_count = 0;
    taking = false;
  }
 
  value_event* add_value(
      int64_t pos, int64_t written, uint16_t key, const ossia::value& v) noexcept
  {
    const bool impulse = v.get_type() == ossia::val_type::IMPULSE;
    const uint8_t pass = uint8_t(count - 1);
    for(int i = event_count - 1; i >= 0; i--)
    {
      auto& e = events[i];
      if(e.pass != pass || e.serial != serial)
        break;
      if(e.key == key && e.impulse == impulse)
      {
        if(e.pos != pos)
          break;
        e.value.set(v);
        edits++;
        return &e;
      }
    }
    if(event_count >= max_events)
    {
      full = true;
      return nullptr;
    }
    edits++;
    auto& e = events[event_count++];
    e.pos = pos;
    e.written = written;
    e.value.set(v);
    e.serial = serial;
    e.key = key;
    e.impulse = impulse;
    e.pass = pass;
    e.replaced_by = 0;
    e.merged = 0;
    return &e;
  }
 
  void write_over(int64_t lo, int64_t hi, double at) noexcept
  {
    if(!taking || count == 0 || touch_count == 0 || at < double(length))
      return;
    const uint8_t pass = uint8_t(count - 1);
    remove_events([&](const value_event& e) {
      return e.pass == pass && e.serial == serial && !e.impulse && e.pos >= lo
             && e.pos < hi && touched(e.key)
             && double(e.written + length) <= at + double(e.pos - lo) + 1e-6;
    });
  }
 
  void assign(const value_loop& o)
  {
    for(int i = 0; i < o.event_count; i++)
      events[i] = o.events[i];
    for(int i = o.event_count; i < event_count; i++)
      events[i].value.reset();
    std::copy_n(o.stretches.begin(), o.stretch_count, stretches.begin());
    event_count = o.event_count;
    stretch_count = o.stretch_count;
    full = o.full;
    next_serial = o.next_serial;
    touches = o.touches;
    touch_count = o.touch_count;
    serial = o.serial;
    whole = o.whole;
    assign_passes(o);
  }
 
  static bool holds(const value_stretch& s, int64_t x, int64_t period) noexcept
  {
    if(s.span >= period)
      return true;
    int64_t d = (x - s.from) % period;
    if(d < 0)
      d += period;
    return d < s.span;
  }
 
  int64_t period_for(int pass) const noexcept
  {
    return std::clamp<int64_t>(period_of(pass), 1, std::max<int64_t>(1, length));
  }
};
 
struct held_scratch
{
  static constexpr int max_refs = 2 * value_loop::max_events;
  struct ref
  {
    int64_t pos;
    uint32_t serial;
    int event;
  };
  std::array<ref, max_refs> refs{};
  int count{};
  std::array<int64_t, max_refs> cuts{};
  bool own_mute{true};
 
  static bool in(int pass, int first, int last) noexcept
  {
    return first < 0 || (pass >= first && pass <= last);
  }
 
  void prepare(const value_loop& loop, uint16_t key, bool own) noexcept
  {
    own_mute = own;
    count = 0;
    const int64_t len = loop.length;
    if(len <= 0)
      return;
    for(int i = 0; i < loop.event_count; i++)
    {
      const auto& e = loop.events[i];
      if(e.key != key || e.impulse || !loop.heard(e, own_mute))
        continue;
      const int64_t period = loop.period_for(e.pass);
      for(int64_t q = e.pos % period; q < len && count < max_refs; q += period)
        refs[count++] = {q, e.serial, i};
    }
    std::sort(refs.begin(), refs.begin() + count, [](const ref& a, const ref& b) {
      if(a.serial != b.serial)
        return a.serial < b.serial;
      if(a.pos != b.pos)
        return a.pos < b.pos;
      return a.event < b.event;
    });
  }
 
  int value_at(
      const value_loop& loop, uint16_t key, int64_t x, int first = -1,
      int last = -1) const noexcept
  {
    bool any = false;
    uint32_t top = 0;
    for(int s = 0; s < loop.stretch_count; s++)
    {
      const auto& st = loop.stretches[s];
      if(st.key != key || !in(st.pass, first, last) || !loop.heard(st, own_mute)
         || !value_loop::holds(st, x, loop.period_for(st.pass)))
        continue;
      if(!any || st.serial > top)
        top = st.serial;
      any = true;
    }
    if(!any)
      return -1;
    auto lo = std::lower_bound(
        refs.begin(), refs.begin() + count, top,
        [](const ref& r, uint32_t s) { return r.serial < s; });
    auto hi = std::upper_bound(
        lo, refs.begin() + count, top, [](uint32_t s, const ref& r) { return s < r.serial; });
    if(lo == hi)
      return -1;
    auto it = std::upper_bound(lo, hi, x, [](int64_t x, const ref& r) { return x < r.pos; });
    return it == lo ? std::prev(hi)->event : std::prev(it)->event;
  }
};
 
struct held_timeline
{
  static constexpr int max_points = held_scratch::max_refs;
  struct point
  {
    int64_t pos;
    int event;
  };
  std::array<point, max_points> points{};
  int count{};
  uint64_t edits{~uint64_t(0)};
  int64_t length{-1};
 
  int at(int64_t x) const noexcept
  {
    if(count == 0)
      return -1;
    auto it = std::upper_bound(
        points.begin(), points.begin() + count, x,
        [](int64_t x, const point& p) { return x < p.pos; });
    const int i = int(it - points.begin()) - 1;
    return i >= 0 ? i : count - 1;
  }
  int before(int64_t x) const noexcept { return at(x - 1); }
  int previous(int i) const noexcept { return i > 0 ? i - 1 : count - 1; }
 
  void update(
      const value_loop& loop, uint16_t key, held_scratch& scratch, int first = -1,
      int last = -1, bool own_mute = true, bool force = false) noexcept
  {
    if(!force && edits == loop.edits && length == loop.length)
      return;
    edits = loop.edits;
    length = loop.length;
    count = 0;
    const int64_t len = loop.length;
    if(len <= 0)
      return;
    scratch.prepare(loop, key, own_mute);
 
    // Where the held value may change: on a value, and where a stretch
    // starts or ends.
    auto& cuts = scratch.cuts;
    int c = 0;
    for(int i = 0; i < scratch.count && c < held_scratch::max_refs; i++)
      if(held_scratch::in(loop.events[scratch.refs[i].event].pass, first, last))
        cuts[c++] = scratch.refs[i].pos;
    for(int s = 0; s < loop.stretch_count; s++)
    {
      const auto& st = loop.stretches[s];
      if(st.key != key || !held_scratch::in(st.pass, first, last)
         || !loop.heard(st, own_mute))
        continue;
      const int64_t period = loop.period_for(st.pass);
      if(st.span >= period)
        continue;
      for(int64_t base = 0; base < len && c + 2 <= held_scratch::max_refs; base += period)
        for(const int64_t q : {base + st.from % period, base + (st.from + st.span) % period})
          if(q < len)
            cuts[c++] = q;
    }
    if(c == 0)
      return;
    if(c < held_scratch::max_refs)
      cuts[c++] = 0;
    std::sort(cuts.begin(), cuts.begin() + c);
    c = int(std::unique(cuts.begin(), cuts.begin() + c) - cuts.begin());
 
    for(int i = 0; i < c; i++)
    {
      const int e = scratch.value_at(loop, key, cuts[i], first, last);
      if(count > 0)
      {
        const int prev = points[count - 1].event;
        if(prev == e
           || (prev >= 0 && e >= 0 && loop.events[prev].value.same(loop.events[e].value)))
          continue;
      }
      points[count++] = {cuts[i], e};
    }
  }
};
}