MidiTake.hpp

#pragma once
#include <Fx/Looper/MidiLoop.hpp>
#include <Fx/Looper/TakeWriter.hpp>
 
#include <libremidi/writer.hpp>
 
#include <algorithm>
#include <array>
#include <atomic>
#include <cmath>
#include <filesystem>
#include <fstream>
#include <memory>
#include <sstream>
#include <vector>
 
namespace Nodes::Looper
{
struct midi_export
{
  std::array<midi_note, midi_loop::max_notes> notes{};
  std::array<midi_control, midi_loop::max_controls> controls{};
  int note_count{};
  int control_count{};
  int64_t length{};
  double rate{48000.};
  double tempo{120.};
  int meter_numerator{4};
  int meter_denominator{4};
  bool wrap{true};
  std::atomic_bool in_use{};
 
  static constexpr int ticks_per_quarter = 480;
 
  std::string to_smf() const
  {
    const double bpm = std::max(1., tempo);
    const double frames_per_quarter = rate * 60. / bpm;
    auto to_tick = [&](int64_t frames) {
      return int64_t(std::llround(frames / frames_per_quarter * ticks_per_quarter));
    };
    const int64_t end = std::max<int64_t>(1, to_tick(length));
 
    struct event
    {
      int64_t tick;
      int order; 
      libremidi::message m;
    };
    std::vector<event> events;
    events.reserve(std::size_t(note_count) * 4 + std::size_t(control_count) + 4);
 
    // A tempo event holds microseconds per quarter on 24 bits.
    const int us_per_quarter
        = int(std::clamp<int64_t>(std::llround(60'000'000. / bpm), 1, 0xFFFFFF));
    events.push_back({0, 1, libremidi::meta_events::tempo(us_per_quarter)});
    // 24 MIDI clocks per metronome click and 8 thirty-seconds per quarter are
    // what every sequencer writes.
    events.push_back(
        {0, 1, libremidi::meta_events::time_signature(
                   std::clamp(meter_numerator, 1, 255),
                   std::clamp(meter_denominator, 1, 128), 24, 8)});
 
    for(int i = 0; i < note_count; i++)
    {
      const auto& n = notes[i];
      const int64_t on = std::clamp<int64_t>(to_tick(n.start), 0, end - 1);
      const int64_t len = std::max<int64_t>(1, to_tick(std::max<int64_t>(1, n.length)));
      int64_t off = on + std::min(len, end - 1);
      const int ch = std::clamp<int>(n.channel, 1, 16);
      events.push_back(
          {on, 2, libremidi::channel_events::note_on(ch, n.pitch, std::max<int>(1, n.velocity))});
      if(off <= end)
      {
        events.push_back({off, 0, libremidi::channel_events::note_off(ch, n.pitch, 0)});
      }
      else if(wrap)
      {
        // The note carries on from the loop's start: its tail is a note of
        // its own there.
        events.push_back({end, 0, libremidi::channel_events::note_off(ch, n.pitch, 0)});
        events.push_back(
            {0, 2, libremidi::channel_events::note_on(ch, n.pitch, std::max<int>(1, n.velocity))});
        events.push_back(
            {std::max<int64_t>(1, off - end), 0, libremidi::channel_events::note_off(ch, n.pitch, 0)});
      }
      else
      {
        events.push_back({end, 0, libremidi::channel_events::note_off(ch, n.pitch, 0)});
      }
    }
 
    for(int i = 0; i < control_count; i++)
    {
      const auto& c = controls[i];
      const int64_t t = std::clamp<int64_t>(to_tick(c.pos), 0, end - 1);
      if((c.status & 0xF0) == 0xD0)
        events.push_back({t, 1, libremidi::message{c.status, c.data1}});
      else
        events.push_back({t, 1, libremidi::message{c.status, c.data1, c.data2}});
    }
 
    // A marker on the loop's end: the end of the track is the end of the
    // loop even when the last note ends earlier.
    events.push_back({end, 3, libremidi::message{0xFF, 0x06, 3, 'e', 'n', 'd'}});
 
    std::stable_sort(events.begin(), events.end(), [](const event& a, const event& b) {
      return a.tick != b.tick ? a.tick < b.tick : a.order < b.order;
    });
 
    libremidi::writer w;
    w.ticksPerQuarterNote = ticks_per_quarter;
    int64_t prev = 0;
    for(const auto& e : events)
    {
      w.add_event(int(e.tick - prev), 0, e.m);
      prev = e.tick;
    }
 
    std::ostringstream out;
    w.write(out);
    return std::move(out).str();
  }
};
 
template <typename Place>
void fill_midi_export(
    const midi_loop& snap, int item, int64_t pos, OverdubMode mode, Place&& place,
    midi_export& e)
{
  e.note_count = 0;
  e.control_count = 0;
  for(int i = 0; i < snap.note_count; i++)
  {
    // A muted pass has its file, as it would be heard.
    auto n = snap.notes[i];
    if(!snap.heard(n, mode, item < 0) || (item >= 0 && n.pass != item))
      continue;
    if(n.length < 0)
      n.length = snap.distance(n.start, pos);
    // A pass shorter than the loop is in the file as many times as it plays.
    const int64_t period = std::clamp<int64_t>(snap.period_of(n.pass), 1, snap.length);
    const auto placed = place(n, period);
    for(int64_t on = placed.start; on < snap.length; on += period)
    {
      if(e.note_count >= midi_loop::max_notes)
        break;
      n.start = on;
      n.length = placed.length;
      e.notes[e.note_count++] = n;
    }
  }
  for(int i = 0; i < snap.control_count; i++)
  {
    const auto& c = snap.controls[i];
    if(!snap.heard(c, item < 0) || (item >= 0 && c.pass != item))
      continue;
    const int64_t period
        = std::max<int64_t>(1, std::min<int64_t>(snap.period_of(c.pass), snap.length));
    for(int64_t q = c.pos % period; q < snap.length; q += period)
    {
      if(e.control_count >= midi_loop::max_controls)
        break;
      e.controls[e.control_count] = c;
      e.controls[e.control_count++].pos = q;
    }
  }
  e.length = snap.length;
}
 
struct midi_stop_take
{
  midi_loop loop;
  OverdubMode mode{};
  double rate{48000.};
  double tempo{120.};
  int meter_numerator{4};
  int meter_denominator{4};
  bool wrap{true};
  stop_take_notice notice;
  std::atomic_bool in_use{};
};
 
struct midi_take_job
{
  std::shared_ptr<take_writer> writer;
  std::shared_ptr<midi_export> data;
  std::shared_ptr<midi_stop_take> stop;
  int slot{};
  int number{};
  int layer{-1};
  bool alone{};
 
  bool write(const midi_export& e)
  {
    const std::string bytes = e.to_smf();
    const auto& path = writer->next_path(slot, number, layer);
    std::ofstream f{
        std::filesystem::path{std::u8string_view{
            reinterpret_cast<const char8_t*>(path.data()), path.size()}},
        std::ios::binary | std::ios::trunc};
    f.write(bytes.data(), std::streamsize(bytes.size()));
    return bool(f);
  }
 
  bool run()
  {
    if(stop)
      return run_stop();
    if(!data)
      return false;
    struct release
    {
      midi_export& e;
      ~release() { e.in_use = false; }
    } done{*data};
    if(!writer || data->length <= 0)
      return false;
    return write(*data);
  }
 
  bool run_stop()
  {
    auto& s = *stop;
    struct release
    {
      midi_stop_take& s;
      ~release() { s.in_use = false; }
    } done{s};
    bool ok = writer && s.loop.length > 0;
    if(ok)
    {
      auto e = std::make_unique<midi_export>();
      e->rate = s.rate;
      e->tempo = s.tempo;
      e->meter_numerator = s.meter_numerator;
      e->meter_denominator = s.meter_denominator;
      e->wrap = s.wrap;
      const auto where = [](const midi_note& n, int64_t) {
        struct
        {
          int64_t start, length;
        } placed{n.start, n.length};
        return placed;
      };
      number = 0;
      for(layer = -1; ok && layer < s.loop.count; layer++)
      {
        fill_midi_export(s.loop, layer, 0, s.mode, where, *e);
        ok = write(*e);
      }
    }
    if(writer)
      s.notice.written(*writer, slot, ok, s.loop.count, true);
    return ok;
  }
};
}