midimapping: tap tempo can also map with CC

Author: mfisher31

include/element/midimapping.hpp

@@ -8,7 +8,7 @@
 #include <element/model.hpp>
 #include <element/tags.hpp>
 
-#define EL_MIDIMAPPING_VERSION 1
+#define EL_MIDIMAPPING_VERSION 2
 
 namespace element {
 
@@ -54,9 +54,39 @@ class MidiMapping : public Model {
     /** For note events: latch on each note-on vs momentary. */
     bool isToggle() const { return (bool) objectData.getProperty (tags::toggle, false); }
 
+    /** For controller events on a trigger-style target (tap tempo): what counts as
+        a trigger. One of "above" (the value crosses up to or through
+        getTriggerValue()), "zero" (the value reaches 0) or "max" (the value
+        reaches 127). Meaningless for note events. */
+    juce::String getTriggerMode() const { return objectData.getProperty (tags::triggerMode, "above").toString(); }
+    /** Threshold used by the "above" trigger mode, 0-127. */
+    int getTriggerValue() const { return (int) objectData.getProperty (tags::triggerValue, 67); }
+
     bool isNoteEvent() const { return getEventType() == "note"; }
     bool isControllerEvent() const { return getEventType() == "controller"; }
 
+    /** Decides whether a controller value transition fires a trigger.
+
+        A continuous controller has no note-on, so a trigger is an edge: the value
+        has to arrive at the mode's condition from somewhere that did not satisfy
+        it. Holding a knob past the threshold therefore fires once, not on every
+        message, and a footswitch sending 127 then 0 fires once per press.
+
+        @param mode          "above", "zero" or "max"; anything else behaves as "above".
+        @param triggerValue  Threshold for "above" mode; ignored by the other modes.
+        @param lastValue     Previously seen controller value, or < 0 if none yet.
+        @param value         The incoming controller value.
+        @return true if this transition should fire the trigger.
+    */
+    static bool isTriggerEdge (const juce::String& mode, int triggerValue, int lastValue, int value)
+    {
+        if (mode == "zero")
+            return value == 0 && lastValue != 0;
+        if (mode == "max")
+            return value == 127 && lastValue != 127;
+        return value >= triggerValue && (lastValue < 0 || lastValue < triggerValue);
+    }
+
     //=========================================================================
     juce::String getTargetType() const { return objectData.getProperty (tags::targetType).toString(); }
     bool isTempoTarget() const { return getTargetType() == "tempo"; }
@@ -142,6 +172,8 @@ class MidiMapping : public Model {
         stabilizePropertyPOD (tags::eventId, 0);
         stabilizePropertyPOD (tags::midiChannel, 0);
         stabilizePropertyPOD (tags::toggle, false);
+        stabilizePropertyString (tags::triggerMode, "above");
+        stabilizePropertyPOD (tags::triggerValue, 67);
         stabilizePropertyString (tags::targetType, "parameter");
         stabilizePropertyString (tags::node, juce::String());
         stabilizePropertyPOD (tags::parameter, -1);

include/element/tags.hpp

@@ -195,6 +195,8 @@ static const juce::Identifier eventType = "eventType";
 static const juce::Identifier eventId = "eventId";
 static const juce::Identifier toggle = "toggle";
 static const juce::Identifier targetType = "targetType";
+static const juce::Identifier triggerMode = "triggerMode";
+static const juce::Identifier triggerValue = "triggerValue";
 } // namespace tags
 
 } // namespace element

src/engine/mappingtarget.cpp

@@ -167,8 +167,16 @@ void ParameterTarget::applyGain (const juce::MidiMessage& message, bool toggle)
 }
 
 //=============================================================================
-TempoTarget::TempoTarget (const juce::ValueTree& sessionData, TapTempo& shared, Signal<void()>& applied)
-    : session (sessionData), tapTempo (shared), tempoTapApplied (applied)
+TempoTarget::TempoTarget (const juce::ValueTree& sessionData,
+                          TapTempo& shared,
+                          Signal<void()>& applied,
+                          const juce::String& mode,
+                          int value)
+    : session (sessionData),
+      tapTempo (shared),
+      tempoTapApplied (applied),
+      triggerMode (mode),
+      triggerValue (value)
 {
 }
 
@@ -179,8 +187,21 @@ bool TempoTarget::isValid() const
 
 void TempoTarget::apply (const juce::MidiMessage& message, bool /*toggle*/)
 {
-    if (! isValid() || ! message.isNoteOn())
-        return; // note-on only: each press is a tap
+    if (! isValid())
+        return;
+
+    if (message.isController())
+    {
+        const int value = message.getControllerValue();
+        const bool fire = MidiMapping::isTriggerEdge (triggerMode, triggerValue, lastControllerValue, value);
+        lastControllerValue = value;
+        if (! fire)
+            return;
+    }
+    else if (! message.isNoteOn())
+    {
+        return; // notes: each press is a tap
+    }
 
     // Flash on every recognised tap (including the seeding first tap of a run,
     // which produces no BPM yet), so the UI feedback matches how a parameter
@@ -211,7 +232,7 @@ std::unique_ptr<MappingTarget> createTarget (const MidiMapping& mapping, Session
 
     if (targetType == "tempo")
     {
-        auto target = std::make_unique<TempoTarget> (session.data(), tapTempo, tempoTapApplied);
+        auto target = std::make_unique<TempoTarget> (session.data(), tapTempo, tempoTapApplied, mapping.getTriggerMode(), mapping.getTriggerValue());
         if (! target->isValid())
             return nullptr;
         return target;

src/engine/mappingtarget.hpp

@@ -62,9 +62,10 @@ class ParameterTarget : public MappingTarget
 };
 
 //=============================================================================
-/** Targets the session tempo as a tap-tempo control: each matching note-on
-    counts as a tap and the averaged BPM is written to the session, which the
-    audio engine picks up on the message thread. */
+/** Targets the session tempo as a tap-tempo control: each matching note-on, or
+    each recognised controller edge, counts as a tap and the averaged BPM is
+    written to the session, which the audio engine picks up on the message
+    thread. */
 class TempoTarget : public MappingTarget
 {
 public:
@@ -73,8 +74,14 @@ class TempoTarget : public MappingTarget
                                 so UI and MIDI taps contribute to the same state.
         @param tempoTapApplied  Fired on every recognised tap so the UI can flash
                                 the TAP button; owned by MappingEngine, so it
-                                outlives this target. */
-    TempoTarget (const juce::ValueTree& sessionData, TapTempo& tapTempo, Signal<void()>& tempoTapApplied);
+                                outlives this target.
+        @param triggerMode      Controller trigger mode, see MidiMapping::isTriggerEdge().
+        @param triggerValue     Threshold for the "above" trigger mode. */
+    TempoTarget (const juce::ValueTree& sessionData,
+                 TapTempo& tapTempo,
+                 Signal<void()>& tempoTapApplied,
+                 const juce::String& triggerMode = "above",
+                 int triggerValue = 67);
     ~TempoTarget() override = default;
 
     bool isValid() const override;
@@ -84,6 +91,9 @@ class TempoTarget : public MappingTarget
     juce::ValueTree session;
     TapTempo& tapTempo;
     Signal<void()>& tempoTapApplied;
+    juce::String triggerMode;
+    int triggerValue;
+    int lastControllerValue { -1 }; // edge state, so a held knob taps only once
 };
 
 //=============================================================================

src/ui/midimappingsview.cpp

@@ -216,8 +216,23 @@ class MidiMappingProperties : public juce::PropertyPanel,
 
         // Latch is meaningful for notes only.
         if (mapping.isNoteEvent())
+        {
             comps.add (new BooleanPropertyComponent (
                 mapping.getPropertyAsValue (tags::toggle), TRANS ("Latch"), TRANS ("Toggle on each note-on")));
+        }
+        else if (mapping.isTempoTarget())
+        {
+            // A knob or switch has no note-on, so the user picks what counts as a tap.
+            comps.add (new ChoicePropertyComponent (
+                mapping.getPropertyAsValue (tags::triggerMode),
+                TRANS ("Trigger"),
+                { TRANS ("At or Above"), TRANS ("Touched 0"), TRANS ("Touched 127") },
+                { var ("above"), var ("zero"), var ("max") }));
+
+            if (mapping.getTriggerMode() == "above")
+                comps.add (new SliderPropertyComponent (
+                    mapping.getPropertyAsValue (tags::triggerValue), TRANS ("Threshold"), 1.0, 127.0, 1.0));
+        }
 
         // Node + parameter only apply to parameter targets; a tempo mapping
         // drives the session tempo (tap tempo) and has no node/parameter.
@@ -323,9 +338,10 @@ class MidiMappingProperties : public juce::PropertyPanel,
         if (onEdited)
             onEdited();
 
-        // Event type flips the CC/Note label and Latch row; node changes the
-        // parameter list. Rebuild async so we never delete the editor mid-callback.
-        if (property == tags::eventType || property == tags::node)
+        // Event type flips the CC/Note label and the Latch/Trigger rows; the
+        // trigger mode shows or hides Threshold; node changes the parameter list.
+        // Rebuild async so we never delete the editor mid-callback.
+        if (property == tags::eventType || property == tags::node || property == tags::triggerMode)
         {
             juce::Component::SafePointer<MidiMappingProperties> self (this);
             juce::MessageManager::callAsync ([self]() mutable {

test/MappingTargetTests.cpp

@@ -162,16 +162,122 @@ BOOST_AUTO_TEST_CASE (TempoTargetTapsFromNoteOn)
     BOOST_REQUIRE_CLOSE ((double) session.getProperty (tags::tempo), 120.0, 0.0001);
     BOOST_REQUIRE_EQUAL (flashes, 2);
 
-    // Note-off and CC never tap: tempo stays put and the flash does not fire.
+    // Note-off never taps: tempo stays put and the flash does not fire.
     session.setProperty (tags::tempo, 100.0, nullptr);
     target.apply (MidiMessage::noteOff (1, 60), false);
-    target.apply (MidiMessage::controllerEvent (1, 7, 127), false);
     BOOST_REQUIRE_CLOSE ((double) session.getProperty (tags::tempo), 100.0, 0.0001);
     BOOST_REQUIRE_EQUAL (flashes, 2);
 
     conn.disconnect();
 }
 
+namespace {
+
+/** A tempo target plus the session tree and flash counter it writes to, so the
+    controller cases below stay about the trigger rule and nothing else. */
+struct TempoFixture
+{
+    TempoFixture (const juce::String& mode = "above", int value = 67)
+        : target (session, shared, tapped, mode, value)
+    {
+        session.setProperty (tags::tempo, 100.0, nullptr);
+        conn = tapped.connect ([this] { ++flashes; });
+    }
+
+    ~TempoFixture() { conn.disconnect(); }
+
+    /** Apply a CC on the mapped controller at the given arrival time. */
+    void cc (int value, double ms = 0.0)
+    {
+        auto m = MidiMessage::controllerEvent (1, 7, value);
+        m.setTimeStamp (ms);
+        target.apply (m, false);
+    }
+
+    double tempo() const { return (double) session.getProperty (tags::tempo); }
+
+    ValueTree session { types::Session };
+    TapTempo shared;
+    Signal<void()> tapped;
+    SignalConnection conn;
+    int flashes = 0;
+    TempoTarget target;
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE (TempoTargetTapsFromCCAboveThreshold)
+{
+    // Default rule: a tap fires when the value crosses up to or through 67.
+    // Twisting back and forth taps once per upward pass, so 500 ms between
+    // crossings is 120 BPM.
+    TempoFixture f;
+
+    f.cc (0, 0.0); // below the threshold: not a tap
+    BOOST_REQUIRE_EQUAL (f.flashes, 0);
+
+    f.cc (80, 100.0); // crossed up: seeds the run
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+    BOOST_REQUIRE_CLOSE (f.tempo(), 100.0, 0.0001);
+
+    f.cc (100, 200.0); // still above: no second tap
+    f.cc (20, 400.0); // falling back down: no tap
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+
+    f.cc (90, 600.0); // crossed up again, 500 ms after the first tap
+    BOOST_REQUIRE_EQUAL (f.flashes, 2);
+    BOOST_REQUIRE_CLOSE (f.tempo(), 120.0, 0.0001);
+}
+
+BOOST_AUTO_TEST_CASE (TempoTargetCCThresholdIsConfigurable)
+{
+    TempoFixture f ("above", 100);
+
+    f.cc (80, 0.0); // above 67 but below the configured threshold
+    BOOST_REQUIRE_EQUAL (f.flashes, 0);
+
+    f.cc (100, 100.0); // exactly at the threshold counts
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+}
+
+BOOST_AUTO_TEST_CASE (TempoTargetCCTouchedZero)
+{
+    TempoFixture f ("zero");
+
+    f.cc (127, 0.0); // never taps: only arriving at 0 does
+    BOOST_REQUIRE_EQUAL (f.flashes, 0);
+
+    f.cc (0, 100.0);
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+
+    f.cc (0, 200.0); // parked at 0: no repeat
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+
+    f.cc (64, 500.0);
+    f.cc (0, 600.0); // back to 0, 500 ms after the first tap
+    BOOST_REQUIRE_EQUAL (f.flashes, 2);
+    BOOST_REQUIRE_CLOSE (f.tempo(), 120.0, 0.0001);
+}
+
+BOOST_AUTO_TEST_CASE (TempoTargetCCTouchedMax)
+{
+    TempoFixture f ("max");
+
+    f.cc (0, 0.0);
+    BOOST_REQUIRE_EQUAL (f.flashes, 0);
+
+    f.cc (127, 100.0);
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+
+    f.cc (127, 200.0); // parked at 127: no repeat
+    BOOST_REQUIRE_EQUAL (f.flashes, 1);
+
+    f.cc (10, 500.0);
+    f.cc (127, 600.0);
+    BOOST_REQUIRE_EQUAL (f.flashes, 2);
+    BOOST_REQUIRE_CLOSE (f.tempo(), 120.0, 0.0001);
+}
+
 BOOST_AUTO_TEST_CASE (InvalidTargets)
 {
     ProcessorPtr obj = new ParamTestNode (1);

test/MidiMappingModelTests.cpp

@@ -22,10 +22,40 @@ BOOST_AUTO_TEST_CASE (DefaultsStabilize)
     BOOST_REQUIRE_EQUAL (m.getEventId(), 0);
     BOOST_REQUIRE_EQUAL (m.getMidiChannel(), 0);
     BOOST_REQUIRE (! m.isToggle());
+    BOOST_REQUIRE (m.getTriggerMode() == "above");
+    BOOST_REQUIRE_EQUAL (m.getTriggerValue(), 67);
     BOOST_REQUIRE (m.getTargetType() == "parameter");
     BOOST_REQUIRE_EQUAL (m.getParameterIndex(), -1);
 }
 
+BOOST_AUTO_TEST_CASE (TriggerEdgeAbove)
+{
+    // Rising crossing only, so a knob held past the threshold fires once.
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("above", 67, -1, 80)); // no history: counts
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("above", 67, -1, 20));
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("above", 67, 20, 67)); // at the threshold counts
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("above", 67, 80, 100)); // already above
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("above", 67, 100, 20)); // falling
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("above", 67, 20, 90));
+
+    // An unknown mode string behaves as "above".
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("bogus", 67, 20, 90));
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("bogus", 67, 80, 100));
+}
+
+BOOST_AUTO_TEST_CASE (TriggerEdgeEndpoints)
+{
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("zero", 67, 64, 0));
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("zero", 67, -1, 0));
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("zero", 67, 0, 0)); // parked at 0
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("zero", 67, 0, 127));
+
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("max", 67, 64, 127));
+    BOOST_REQUIRE (MidiMapping::isTriggerEdge ("max", 67, -1, 127));
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("max", 67, 127, 127)); // parked at 127
+    BOOST_REQUIRE (! MidiMapping::isTriggerEdge ("max", 67, 127, 64));
+}
+
 BOOST_AUTO_TEST_CASE (FromCaptureController)
 {
     Uuid node;