midi_event.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <algorithm>
#include <cstdint>
#include <cstring>
 
#include "utils/types.h"
 
#include <crill/spin_mutex.h>
 
namespace juce
{
class MidiMessageSequence;
}
 
namespace zrythm::dsp
{
class ChordDescriptor;

constexpr int MAX_MIDI_EVENTS = 2560;

struct MidiEvent final
{
public:
  // Rule of 0
  MidiEvent () = default;
  MidiEvent (
    midi_byte_t byte1,
    midi_byte_t byte2,
    midi_byte_t byte3,
    midi_time_t time)
      : raw_buffer_sz_ (3), time_ (time)
  {
    raw_buffer_[0] = byte1;
    raw_buffer_[1] = byte2;
    raw_buffer_[2] = byte3;
  }
 
  void set_velocity (midi_byte_t vel);
 
  void print () const;
 
public:
  std::array<midi_byte_t, 3> raw_buffer_{ 0, 0, 0 };
 
  uint_fast8_t raw_buffer_sz_ = 0;

  midi_time_t time_ = 0;

  std::int64_t systime_ = 0;
};
 
inline bool
operator== (const MidiEvent &lhs, const MidiEvent &rhs)
{
  return lhs.time_ == rhs.time_ && lhs.raw_buffer_[0] == rhs.raw_buffer_[0]
         && lhs.raw_buffer_[1] == rhs.raw_buffer_[1]
         && lhs.raw_buffer_[2] == rhs.raw_buffer_[2]
         && lhs.raw_buffer_sz_ == rhs.raw_buffer_sz_;
}

class MidiEventVector final
{
public:
  MidiEventVector () { events_.reserve (MAX_MIDI_EVENTS); }
 
  using ChordDescriptor = dsp::ChordDescriptor;
 
  // Iterator types
  using Iterator = std::vector<MidiEvent>::iterator;
  using ConstIterator = std::vector<MidiEvent>::const_iterator;
 
  // Iterator methods
  Iterator begin ()
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.begin ();
  }
 
  Iterator end ()
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.end ();
  }
 
  void erase (Iterator it, Iterator it_end)
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    events_.erase (it, it_end);
  }
 
  ConstIterator begin () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.begin ();
  }
 
  ConstIterator end () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.end ();
  }
 
  void push_back (const MidiEvent &ev)
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    events_.push_back (ev);
  }
 
  void push_back (const std::vector<MidiEvent> &events)
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    events_.insert (events_.end (), events.begin (), events.end ());
  }
 
  MidiEvent pop_front ()
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    MidiEvent                                ev = events_.front ();
    events_.erase (events_.begin ());
    return ev;
  }
 
  MidiEvent pop_back ()
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    MidiEvent                                ev = events_.back ();
    events_.pop_back ();
    return ev;
  }
 
  void clear ()
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    events_.clear ();
  }
 
  size_t size () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.size ();
  }
 
  MidiEvent front () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.front ();
  }
 
  MidiEvent back () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.back ();
  }
 
  MidiEvent at (size_t index) const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.at (index);
  }
 
  void swap (MidiEventVector &other)
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    events_.swap (other.events_);
  }
 
  void remove_if (std::function<bool (const MidiEvent &)> predicate)
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    // std::erase_if (events_, std::move (predicate)); // fails to build on
    // Xcode 26
    auto it =
      std::remove_if (events_.begin (), events_.end (), std::move (predicate));
    events_.erase (it, events_.end ());
  }

  void remove (const MidiEvent &event)
  {
    remove_if ([&event] (const MidiEvent &e) { return e == event; });
  }
 
  void foreach_event (std::function<void (const MidiEvent &)> func) const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    std::ranges::for_each (events_, func);
  }
 
  size_t capacity () const
  {
    const std::lock_guard<crill::spin_mutex> lock (lock_);
    return events_.capacity ();
  }
 
  void print () const;

  [[gnu::hot]] void append_w_filter (
    const MidiEventVector              &src,
    std::optional<std::array<bool, 16>> channels,
    nframes_t                           local_offset,
    nframes_t                           nframes);

  void
  append (const MidiEventVector &src, nframes_t local_offset, nframes_t nframes);
 
  using NotePitchToChordDescriptorFunc =
    std::function<const ChordDescriptor *(midi_byte_t)>;

  void transform_chord_and_append (
    const MidiEventVector         &src,
    NotePitchToChordDescriptorFunc note_number_to_chord_descriptor,
    midi_byte_t                    velocity_to_use,
    nframes_t                      local_offset,
    nframes_t                      nframes);

  void add_note_on (
    midi_byte_t channel,
    midi_byte_t note_pitch,
    midi_byte_t velocity,
    midi_time_t time);

  void add_note_ons_from_chord_descr (
    const ChordDescriptor &descr,
    midi_byte_t            channel,
    midi_byte_t            velocity,
    midi_time_t            time);

  void add_note_offs_from_chord_descr (
    const ChordDescriptor &descr,
    midi_byte_t            channel,
    midi_time_t            time);

  void
  add_cc_volume (midi_byte_t channel, midi_byte_t volume, midi_time_t time);
 
#if 0
  bool has_note_on (bool check_main, bool check_queued);
#endif
 
  bool has_any () const { return !empty (); }
  bool empty () const { return size () == 0; }

  void add_event_from_buf (midi_time_t time, midi_byte_t * buf, int buf_size);

  void
  add_note_off (midi_byte_t channel, midi_byte_t note_pitch, midi_time_t time);

  void add_control_change (
    midi_byte_t channel,
    midi_byte_t controller,
    midi_byte_t control,
    midi_time_t time);

  void add_song_pos (int64_t total_sixteenths, midi_time_t time);
 
  void add_raw (const uint8_t * buf, size_t buf_sz, midi_time_t time);
 
  void add_simple (
    midi_byte_t byte1,
    midi_byte_t byte2,
    midi_byte_t byte3,
    midi_time_t time)
  {
    push_back (MidiEvent (byte1, byte2, byte3, time));
  }

  void
  add_pitchbend (midi_byte_t channel, uint32_t pitchbend, midi_time_t time);
 
  void
  add_channel_pressure (midi_byte_t channel, midi_byte_t value, midi_time_t time);

  void
  add_all_notes_off (midi_byte_t channel, midi_time_t time, bool with_lock);

  void panic_without_lock (midi_time_t time)
  {
    for (midi_byte_t i = 1; i < 17; i++)
      {
        add_all_notes_off (i, time, false);
      }
  }

  void panic ();

  void write_to_midi_sequence (
    juce::MidiMessageSequence &sequence,
    bool                       update_matched_pairs) const;

  void clear_duplicates ();
 
#if 0
  bool check_for_note_on (int note);

  bool delete_note_on (int note);
#endif

  void sort ();

  void set_channel (midi_byte_t channel);
 
  void delete_event (const MidiEvent * ev);
 
private:
  std::vector<MidiEvent> events_;

  mutable crill::spin_mutex lock_;
};

class MidiEvents final
{
public:
  void dequeue (nframes_t local_offset, nframes_t nframes);
 
public:
  MidiEventVector active_events_;

  MidiEventVector queued_events_;
};
 
} // namespace zrythm::dsp