Midi note shift node, cleanup

Author: nick-thompson

runtime/elem/BlockEvents.h

@@ -27,21 +27,6 @@ struct MidiEvent {
     {}
 };
 
-struct AssignedMidiEvent {
-    choc::midi::ShortMessage message;
-    size_t voiceIndex;
-
-    AssignedMidiEvent(uint8_t byte0, uint8_t byte1, uint8_t byte2)
-        : message(byte0, byte1, byte2)
-        , voiceIndex(0)
-    {}
-
-    AssignedMidiEvent(choc::midi::ShortMessage const& msg)
-        : message(msg)
-        , voiceIndex(0)
-    {}
-};
-
 // Type-erased event structure that can hold any event type within a certain
 // size. The event struct holds its data strictly in stack-allocated space.
 struct BlockEvent {

runtime/elem/DefaultNodeTypes.h

@@ -147,6 +147,7 @@ namespace elem
             callback("midinotein",          GenericNodeFactory<MidiNoteInNode<FloatType>>());
             callback("midinoteallocate",    GenericNodeFactory<MidiNoteAllocateNode<FloatType>>());
             callback("midinoteunpack",      GenericNodeFactory<MidiNoteUnpackNode<FloatType>>());
+            callback("midinoteshift",       GenericNodeFactory<MidiNoteShiftNode<FloatType>>());
         }
     };
 

runtime/elem/Runtime.h

@@ -284,7 +284,6 @@ namespace elem
     void Runtime<FloatType>::process(const FloatType** inputChannelData, size_t numInputChannels, FloatType** outputChannelData, size_t numOutputChannels, size_t numSamples, void* userData)
     {
         BlockEvents emptyInputEvents;
-        // SmallVec!
         BlockEvents emptyOutputEvents;
 
         process(BlockContext<FloatType> {

runtime/elem/builtins/MIDI.h

@@ -122,6 +122,11 @@ namespace elem
         int64_t steadyClock = 0;
     };
 
+    // Maps incoming midi note events into audio signal data.
+    //
+    // This will constantly emit a pair of audio signals representing
+    // the note frequency (in Hz) and note velocity (0-1) of the most
+    // recent midi note that it has processed.
     template <typename FloatType>
     struct MidiNoteUnpackNode : public GraphNode<FloatType> {
         using GraphNode<FloatType>::GraphNode;
@@ -181,4 +186,39 @@ namespace elem
         FloatType noteVelocity = 0;
     };
 
+    // A simple pitch utility for midi events.
+    //
+    // For every incoming midi note event, this will nudge the associated
+    // note value according to the steps property.
+    template <typename FloatType>
+    struct MidiNoteShiftNode : public GraphNode<FloatType> {
+        using GraphNode<FloatType>::GraphNode;
+
+        int setProperty(std::string const& key, js::Value const& val) override
+        {
+            if (key == "steps") {
+                if (!val.isNumber())
+                    return ReturnCode::InvalidPropertyType();
+
+                auto v = static_cast<int32_t>((js::Number) val);
+                steps.store(v);
+            }
+
+            return GraphNode<FloatType>::setProperty(key, val);
+        }
+
+        void process (BlockContext<FloatType> const& ctx) override {
+            auto const s = steps.load();
+
+            ctx.inputEvents.template processEventsOfType<MidiEvent>([&](size_t time, MidiEvent const& event) {
+                auto* bytes = event.message.data();
+                auto newNoteValue = std::max(0, std::min(127, static_cast<int32_t>(bytes[1]) + s));
+                auto shiftedEvent = MidiEvent(bytes[0], static_cast<uint8_t>(newNoteValue), bytes[2]);
+                ctx.outputEvents.addEvent(time, std::move(shiftedEvent));
+            });
+        }
+
+        std::atomic<int32_t> steps = 0;
+    };
+
 } // namespace elem