Sequencer - ditch std::vector replace with cb. use i8 as seqdata type. take init out of the ctor.

src/main_osp.cc

@@ -54,6 +54,7 @@ namespace Heck::OSP {
 
     void init_tracks()
     {
+        sequencer.init();
         tracks[0].init(instrument0);
         tracks[1].init(instrument1);
         tracks[2].init(instrument2);
@@ -242,10 +243,7 @@ namespace Heck::OSP {
 
     void midi_from_sequencer()
     {
-        std::vector<ld::MidiEvent> queue = sequencer.midi_out();
+        sequencer.midi_out([](ld::MidiEvent msg) { midi_dispatch(msg, true); });
-        for (ld::MidiEvent msg : queue) {
-            midi_dispatch(msg, true);
-        }
     }
 
     //-------------------------------------------------

src/sequencer.cc

@@ -1,72 +1,88 @@
 #include "sequencer.hh"
 
 namespace Heck::OSP {
-    Sequencer::Sequencer()
+    constexpr i8 EMPTY = -1;
+
+    Sequencer::Sequencer() {}
+
+    void Sequencer::init()
     {
+        step_current_ = 0;
+        recording_ = false;
         clear_sequence();
     }
 
     void Sequencer::reset()
     {
-        step_current = 0;
+        step_current_ = 0;
+    }
+
+    bool Sequencer::recording(bool set_rec)
+    {
+        recording_ = set_rec;
+        return recording_;
     }
 
     void Sequencer::next_step()
     {
-        step_current++;
+        step_current_++;
-        if (step_current >= STEP_COUNT) {
+        if (step_current_ >= STEP_COUNT) {
-            step_current = 0;
+            step_current_ = 0;
         }
     }
 
-    void Sequencer::clear_track(int track_nr)
+    void Sequencer::clear_track(i8 track_nr)
     {
-        for (int step = 0; step < STEP_COUNT; step++) {
+        for (i8 step = 0; step < STEP_COUNT; step++) {
-            for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
+            for (i8 cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
-                sequence[track_nr][step][cc_nr] = -1;
+                sequence_[track_nr][step][cc_nr] = EMPTY;
             }
         }
     }
 
-    void Sequencer::clear_track_cc(int track_nr, int cc_nr)
+    void Sequencer::clear_track_cc(i8 track_nr, i8 cc_nr)
     {
-        for (int step = 0; step < STEP_COUNT; step++) {
+        for (i8 step = 0; step < STEP_COUNT; step++) {
-            sequence[track_nr][step][cc_nr] = -1;
+            sequence_[track_nr][step][cc_nr] = EMPTY;
         }
     }
 
     void Sequencer::clear_sequence()
     {
-        for (int track = 0; track < TRACK_COUNT; track++) {
+        for (i8 track = 0; track < TRACK_COUNT; track++) {
             clear_track(track);
         }
     }
 
     void Sequencer::midi_in(ld::MidiEvent& msg)
     {
-        if (recording) {
+        if (recording_) {
             ld::ControlChangeEvent cc = msg.AsControlChange();
-            sequence[cc.channel][step_current][cc.control_number] = cc.value;
+            sequence_[cc.channel][step_current_][cc.control_number] = cc.value;
         }
     }
 
-    std::vector<ld::MidiEvent> Sequencer::midi_out()
+    void Sequencer::midi_out(Sequencer::MidiOutCallback cb)
     {
-        std::vector<ld::MidiEvent> ret{};
+        if (!cb) {
-        for (int track = 0; track < TRACK_COUNT; track++) {
+            ld::DaisySeed::PrintLine("Sequencer: Error - no midi out callback registered");
-            for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
+            return;
-                int cc_val = sequence[track][step_current][cc_nr];
+        } else {
-                if (cc_val != -1) {
+            for (i8 track = 0; track < TRACK_COUNT; track++) {
-                    ld::MidiEvent ev{};
+                for (i8 cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
-                    ev.channel = track;
+                    i8 cc_val = sequence_[track][step_current_][cc_nr];
-                    ev.type = ld::ControlChange;
+                    if (cc_val != EMPTY) {
-                    ev.data[0] = cc_nr;
+                        ld::MidiEvent ev{};
-                    ev.data[1] = cc_val;
+                        ev.channel = track;
-                    ret.push_back(ev);
+                        ev.type = ld::ControlChange;
+                        ev.data[0] = cc_nr;
+                        ev.data[1] = cc_val;
+                        cb(ev);
+                    }
                 }
             }
+            return;
         }
-        return ret;
     }
 
-} // namespace Heck
+} // namespace Heck::OSP

src/sequencer.hh

@@ -3,32 +3,37 @@
 
 #include <vector>
 #include "daisy_seed.h"
+#include "dizzy_types.hh"
 
 namespace ld = daisy;
 
 namespace Heck::OSP {
     struct Sequencer {
         // its a MIDI CC step sequencer
-        constexpr static int MIDI_MAX = 127;
+        constexpr static i8 MIDI_MAX = 127;
-        constexpr static int STEP_COUNT = 16;
+        constexpr static i8 STEP_COUNT = 16;
-        constexpr static int TRACK_COUNT = 16;
+        constexpr static i8 TRACK_COUNT = 4;
 
-        using Step = std::array<int, MIDI_MAX>;
+        using MidiOutCallback = std::function<void(ld::MidiEvent ev)>;
+
+        using Step = std::array<i8, MIDI_MAX>;
         using Track = std::array<Step, STEP_COUNT>;
         using Sequence = std::array<Track, TRACK_COUNT>;
 
         Sequencer();
+        void init();
         void reset();
         void next_step();
-        void clear_track(int track_nr);
+        bool recording(bool set_rec);
-        void clear_track_cc(int track_nr, int cc_nr);
+        void clear_track(i8 track_nr);
+        void clear_track_cc(i8 track_nr, i8 cc_nr);
         void clear_sequence();
         void midi_in(ld::MidiEvent& msg);
-        std::vector<ld::MidiEvent> midi_out();
+        void midi_out(Sequencer::MidiOutCallback cb);
-
+    private:
-        int step_current{ 0 };
+        i8 step_current_;
-        bool recording{ false };
+        bool recording_;
-        Sequence sequence{};
+        Sequence sequence_;
     };
 } // namespace Heck