MidiLoop.hpp

#pragma once
#include <Fx/Looper/PassStack.hpp>
 
#include <Advanced/MidiScaler/MidiCommon/Messages.hpp>
 
#include <algorithm>
#include <array>
#include <bit>
#include <cmath>
#include <cstdint>
#include <utility>
 
namespace Nodes::Looper
{
enum class OverdubMode
{
  Merge,  
  Replace 
};
 
enum class HeldNotes
{
  Wrap,    
  Truncate 
};
 
struct midi_note
{
  int64_t start;
  int64_t length;
  uint8_t channel; 
  uint8_t pitch;
  uint8_t velocity;
  uint8_t pass;
  uint64_t replaced_by;
  uint8_t merged;
};
 
struct midi_control
{
  int64_t pos;
  uint8_t status;
  uint8_t data1;
  uint8_t data2;
  uint8_t pass;
  uint64_t replaced_by;
  uint8_t merged;
 
  uint16_t key() const noexcept
  {
    const uint8_t kind = status & 0xF0;
    const bool indexed = kind == 0xB0 || kind == 0xA0;
    return uint16_t(status << 8 | (indexed ? data1 : 0));
  }
};
 
using midi_pass = tagged_pass;
 
struct midi_loop : tagged_pass_stack<midi_loop, midi_pass, 32>
{
  static constexpr int max_notes = 4096;
  static constexpr int max_controls = 8192;
  static constexpr int max_touched = 64;
 
  std::array<midi_note, max_notes> notes{};
  std::array<midi_control, max_controls> controls{};
  int note_count{};
  int control_count{};
  bool full{};
 
  // What the pass being recorded touched.
  std::array<bool, 128> touched_pitches{};
  std::array<uint16_t, max_touched> touched_keys{};
  int touched_count{};
 
  // tagged_pass_stack's hooks: the events are the material.
  void clear_material() noexcept
  {
    note_count = 0;
    control_count = 0;
    full = false;
  }
  void pass_state_begun() noexcept
  {
    touched_pitches.fill(false);
    touched_count = 0;
  }
  template <typename F>
  void for_each_material(F&& f) noexcept
  {
    for_each_event(std::forward<F>(f));
  }
  template <typename F>
  void remove_material(F&& gone) noexcept
  {
    remove_events(std::forward<F>(gone));
  }
 
  bool touched(uint16_t key) const noexcept
  {
    for(int i = 0; i < touched_count; i++)
      if(touched_keys[i] == key)
        return true;
    return false;
  }
 
  bool heard(const midi_note& n, OverdubMode mode, bool own_mute = true) const noexcept
  {
    if(n.pass >= count || replaced(n.replaced_by, n.pass, taking)
       || (own_mute && layers[n.pass].muted))
      return false;
    if(replacing() && n.pass + 1 < count && mode == OverdubMode::Replace
       && touched_pitches[n.pitch] && in_pass(n.start))
      return false;
    return true;
  }
 
  bool heard(const midi_control& c, bool own_mute = true) const noexcept
  {
    if(c.pass >= count || replaced(c.replaced_by, c.pass, taking)
       || (own_mute && layers[c.pass].muted))
      return false;
    if(replacing() && c.pass + 1 < count && touched(c.key()) && in_pass(c.pos))
      return false;
    return true;
  }
 
  template <typename F>
  void remove_events(F&& gone) noexcept
  {
    note_count = int(
        std::remove_if(notes.begin(), notes.begin() + note_count, gone) - notes.begin());
    control_count = int(
        std::remove_if(controls.begin(), controls.begin() + control_count, gone)
        - controls.begin());
  }
 
  template <typename F>
  void for_each_event(F&& f) noexcept
  {
    for(int i = 0; i < note_count; i++)
      f(notes[i]);
    for(int i = 0; i < control_count; i++)
      f(controls[i]);
  }
 
  void end_pass(OverdubMode mode) noexcept
  {
    if(!taking)
      return;
    const int pass = count - 1;
    edits++;
    if(pass > 0)
    {
      const uint64_t bit = uint64_t(1) << pass;
      for(int i = 0; i < note_count; i++)
      {
        auto& n = notes[i];
        if(n.pass < pass && mode == OverdubMode::Replace && touched_pitches[n.pitch]
           && in_pass(n.start))
          n.replaced_by |= bit;
      }
      for(int i = 0; i < control_count; i++)
      {
        auto& c = controls[i];
        if(c.pass < pass && touched(c.key()) && in_pass(c.pos))
          c.replaced_by |= bit;
      }
    }
    taking = false;
  }
 
  void assign(const midi_loop& o) noexcept
  {
    std::copy_n(o.notes.begin(), o.note_count, notes.begin());
    std::copy_n(o.controls.begin(), o.control_count, controls.begin());
    note_count = o.note_count;
    control_count = o.control_count;
    full = o.full;
    assign_passes(o);
    touched_pitches = o.touched_pitches;
    touched_keys = o.touched_keys;
    touched_count = o.touched_count;
  }
 
  midi_note* add_note(int64_t pos, int channel, int pitch, int velocity) noexcept
  {
    if(note_count >= max_notes)
    {
      full = true;
      return nullptr;
    }
    touched_pitches[pitch & 127] = true;
    auto& n = notes[note_count++];
    n = midi_note{
        .start = pos,
        .length = -1,
        .channel = uint8_t(channel),
        .pitch = uint8_t(pitch),
        .velocity = uint8_t(velocity),
        .pass = uint8_t(count - 1),
        .replaced_by = 0,
        .merged = 0};
    return &n;
  }
 
  midi_note* open_note(int channel, int pitch) noexcept
  {
    for(int i = 0; i < note_count; i++)
    {
      auto& n = notes[i];
      if(n.length < 0 && n.channel == channel && n.pitch == pitch)
        return &n;
    }
    return nullptr;
  }
 
  void add_control(int64_t pos, uint8_t status, uint8_t d1, uint8_t d2) noexcept
  {
    if(control_count >= max_controls)
    {
      full = true;
      return;
    }
    edits++;
    auto& c = controls[control_count++];
    c = midi_control{
        .pos = pos,
        .status = status,
        .data1 = d1,
        .data2 = d2,
        .pass = uint8_t(count - 1),
        .replaced_by = 0,
        .merged = 0};
    const auto key = c.key();
    if(!touched(key) && touched_count < max_touched)
      touched_keys[touched_count++] = key;
  }
 
  void touch(uint16_t key) noexcept
  {
    if(!touched(key) && touched_count < max_touched)
      touched_keys[touched_count++] = key;
  }
 
  void close_open_notes(int64_t pos) noexcept
  {
    for(int i = 0; i < note_count; i++)
    {
      auto& n = notes[i];
      if(n.length < 0)
        n.length = distance(n.start, pos);
    }
  }
};
}