vst2_events

core/audio/midi_sequencer/clip/clip.h

@@ -5,4 +5,6 @@ class clip {
 public:
     virtual ~clip() = default;
     virtual auto get_length() -> midi_tick = 0;
+    virtual void process(midi_tick tick, midi_tick length) = 0;
+    virtual void reset() = 0;
 };

core/audio/midi_sequencer/clip/midi_clip.cpp

@@ -1 +1,16 @@
 #include "midi_clip.h"
+
+void midi_track::process(midi_tick tick, midi_tick length) {
+    const uint64_t end_tick = tick + length;
+    for (; last_index_ < events_.size(); ++last_index_) {
+        auto& event = events_[last_index_];
+        if (event.tick >= end_tick) {
+            break;
+        }
+        host_->
+    }
+}
+
+void midi_clip::process(midi_tick tick, midi_tick length) {
+    auto end_tick = tick += length;
+}

core/audio/midi_sequencer/clip/midi_clip.h

@@ -3,9 +3,34 @@
 #include "misc/mempool.h"
 #include "MidiEventList.h"
 
+
+class plugin_host;
+
+class midi_track : public pool_obj<midi_track> {
+public:
+    midi_track(plugin_host* host) : host_(host) {}
+    void process(midi_tick tick, midi_tick length);
+    void reset() {
+        last_index_ = 0;
+    }
+private:
+    plugin_host* host_;
+    smf::MidiEventList events_;
+    int32_t last_index_ = 0;
+};
+
 class midi_clip : public clip, public pool_obj<midi_clip> {
 public:
-
+    auto get_length() -> midi_tick override {
+        return length_;
+    }
+    void process(midi_tick tick, midi_tick length) override;
+    void reset() override {
+        for (auto track : tracks_) {
+            track->reset();
+        }
+    }
 private:
-    smf::MidiEventList events;
+    midi_tick length_;
+    std::vector<midi_track*> tracks_;
 };

core/audio/plugin_host/plugin_host.h

@@ -4,6 +4,7 @@
 #include <vector>
 #include "extern.h"
 #include "host_param.h"
+#include "MidiEventList.h"
 #include "../../misc/mempool.h"
 #include "audio/misc/circular_audio_buffer.h"
 #include "misc/delegates.h"
@@ -57,6 +58,7 @@ public:
     virtual void update_channel_node_name() {}
 
     virtual void process(uint32_t frame_num) = 0;
+    virtual void push_midi(const smf::MidiEvent& event, uint32_t frame_delta) = 0;
 
     void try_open_editor();
 

core/audio/plugin_host/vst2/vst2_plugin_host.cpp

@@ -125,6 +125,25 @@ VstIntPtr vst_master_callback(AEffect* effect, VstInt32 opcode, VstInt32 index,
 
 typedef AEffect*(*vst_plugin_entry_proc)(audioMasterCallback AudioMaster);
 
+void vst2_events::push(const smf::MidiEvent& event, uint32_t frame_delta) {
+    VstMidiEvent midi_event{};
+    midi_event.type = kVstMidiType;
+    midi_event.byteSize = sizeof(VstMidiEvent);
+    midi_event.deltaFrames = frame_delta;
+    midi_event.midiData[0] = event[0];
+    midi_event.midiData[1] = event[1];
+    midi_event.midiData[2] = event[2];
+    midi_events_.push_back(midi_event);
+
+    vst_events_.numEvents = static_cast<VstInt32>(midi_events_.size());
+    vst_events_.events[0] = (VstEvent*)midi_events_.data();
+}
+
+void vst2_events::clear() {
+    midi_events_.clear();
+    vst_events_.numEvents = 0;
+}
+
 vst2_plugin_host::vst2_plugin_host() : plugin_host(type) {
     effect_ = nullptr;
     library_ = nullptr;
@@ -216,6 +235,12 @@ void vst2_plugin_host::process(uint32_t frame_num) {
     for (int i = 0; i < ui_buffers->size(); ++i) {
         ui_buffers->at(i).push(channel->get_output_headers()[i], frame_num);
     }
+    events_.clear();
+}
+
+void vst2_plugin_host::push_midi(const smf::MidiEvent& event, uint32_t frame_delta) {
+    events_.push(event, frame_delta);
+    dispatch(effProcessEvents, 0, 0, events_.get());
 }
 
 void vst2_plugin_host::idle_editor() {

core/audio/plugin_host/vst2/vst2_plugin_host.h

@@ -4,6 +4,18 @@
 #include "pluginterfaces/vst2.x/aeffect.h"
 #include "pluginterfaces/vst2.x/aeffectx.h"
 
+class vst2_events {
+public:
+    void push(const smf::MidiEvent& event, uint32_t frame_delta);
+    void clear();
+    [[nodiscard]] auto get() -> VstEvents* {
+        return &vst_events_;
+    }
+private:
+    VstEvents vst_events_;
+    std::vector<VstMidiEvent> midi_events_;
+};
+
 class vst2_plugin_host : public plugin_host, public pool_obj<vst2_plugin_host> {
 public:
     static VstTimeInfo vst_time_info;
@@ -22,6 +34,7 @@ public:
     void update_channel_node_name() override;
 
     void process(uint32_t frame_num) override;
+    void push_midi(const smf::MidiEvent& event, uint32_t frame_delta) override;
 
     void idle_editor() override;
     [[nodiscard]] bool has_editor() const override;
@@ -47,6 +60,7 @@ private:
     VstIntPtr dispatch(VstInt32 opcode, VstInt32 index = 0, VstIntPtr value = 0, void* ptr = nullptr, float opt = 0) const;
     AEffect* effect_;
     std::shared_ptr<dynamic_library> library_;
+    vst2_events events_;
     bool enabled_ = false;
 };
 

core/misc/tick.h

@@ -12,13 +12,22 @@ public:
     }
     explicit midi_tick(const audio_frame& in_frame);
 
-    [[nodiscard]] audio_frame to_audio_frame() const;
+    [[nodiscard]] auto to_audio_frame() const -> audio_frame;
-    [[nodiscard]] int64_t get_ticks() const {
+    [[nodiscard]] auto get_ticks() const -> int64_t {
         return ticks;
     }
     operator int64_t() const {
         return ticks;
     }
+    auto operator<=>(const midi_tick&) const = default;
+    auto operator+=(const midi_tick& in_tick) -> midi_tick {
+        ticks += in_tick.ticks;
+        return *this;
+    }
+    auto operator-=(const midi_tick& in_tick) -> midi_tick {
+        ticks -= in_tick.ticks;
+        return *this;
+    }
 private:
     int64_t ticks;
 };
@@ -30,19 +39,19 @@ public:
     }
     explicit audio_frame(const midi_tick& in_tick);
 
-    [[nodiscard]] midi_tick to_midi_tick() const;
+    [[nodiscard]] auto to_midi_tick() const -> midi_tick;
-    [[nodiscard]] int64_t get_frames() const {
+    [[nodiscard]] auto get_frames() const -> int64_t {
         return frames;
     }
     operator int64_t() const {
         return frames;
     }
     auto operator<=>(const audio_frame&) const = default;
-    audio_frame operator+=(const audio_frame& in_frame) {
+    auto operator+=(const audio_frame& in_frame) -> audio_frame {
         frames += in_frame.frames;
         return *this;
     }
-    audio_frame operator-=(const audio_frame& in_frame) {
+    auto operator-=(const audio_frame& in_frame) -> audio_frame {
         frames -= in_frame.frames;
         return *this;
     }