Add velocity sensitivity to Piano Synth V3

Author: juzzlin

CHANGELOG

@@ -14,6 +14,9 @@ New features:
   - The strings come in twos, never threes, and single stringing reaches to F#1:
     a CP80 is bichord over its whole compass
   - A separate device, so songs written against V2 keep playing V2
+  - A Velocity Sensitivity control: full is the reference's own velocity-squared
+    law, lower lifts the softer strikes toward the loud ones without changing
+    their tone, so the top of the keyboard is playable without hammering it
 
 * Add the Gain rack effect: a plain +/-24 dB trim with a latching clip indicator,
   for staging level without the colour a limiter or a drive brings

src/domain/devices/piano_synth_v3_device.cpp

@@ -56,6 +56,7 @@ PianoSynthV3Device::PianoSynthV3Device(std::string name)
     addParameter(Parameter(Constants::NahdXml::xmlKeyRichness().toStdString(), 0.7f, 0, 10000, 7000, 100));
     addParameter(Parameter(Constants::NahdXml::xmlKeyDoubleDecay().toStdString(), 0.5f, 0, 10000, 5000, 100));
     addParameter(Parameter(Constants::NahdXml::xmlKeyAttack().toStdString(), 0.5f, 0, 10000, 5000, 100));
+    addParameter(Parameter(Constants::NahdXml::xmlKeyAmpVelocitySensitivity().toStdString(), 1.0f, 0, 10000, 10000, 100));
     addParameter(Parameter(Constants::NahdXml::xmlKeyLpfCutoff().toStdString(), 1.0f, 0, 10000, 10000, 100));
     addParameter(Parameter(Constants::NahdXml::xmlKeyHpfCutoff().toStdString(), 0.0f, 0, 10000, 0, 100));
     addParameter(Parameter(Constants::NahdXml::xmlKeyReleaseTime().toStdString(), 0.15f, 0, 10000, 1500, 100));
@@ -319,7 +320,8 @@ ModalPianoStringV3::Settings PianoSynthV3Device::stringSettings() const
         m_stretch,
         m_richness,
         m_doubleDecay,
-        m_attack
+        m_attack,
+        m_velocitySensitivity
     };
 }
 
@@ -417,6 +419,9 @@ void PianoSynthV3Device::syncParameters()
     if (const auto p = parameter(Constants::NahdXml::xmlKeyAttack().toStdString()); p) {
         m_attack = p->get().value();
     }
+    if (const auto p = parameter(Constants::NahdXml::xmlKeyAmpVelocitySensitivity().toStdString()); p) {
+        m_velocitySensitivity = p->get().value();
+    }
     if (const auto p = parameter(Constants::NahdXml::xmlKeyLpfCutoff().toStdString()); p) {
         m_lpfCutoff = p->get().value();
     }
@@ -521,6 +526,16 @@ void PianoSynthV3Device::setAttack(float attack)
     setContinuousParameterValue(Constants::NahdXml::xmlKeyAttack().toStdString(), attack);
 }
 
+float PianoSynthV3Device::velocitySensitivity() const
+{
+    return m_velocitySensitivity;
+}
+
+void PianoSynthV3Device::setVelocitySensitivity(float sensitivity)
+{
+    setContinuousParameterValue(Constants::NahdXml::xmlKeyAmpVelocitySensitivity().toStdString(), sensitivity);
+}
+
 float PianoSynthV3Device::lpfCutoff() const
 {
     return m_lpfCutoff;

src/domain/devices/piano_synth_v3_device.hpp

@@ -82,6 +82,10 @@ class PianoSynthV3Device : public Device
     //! Scales the ramp the strike opens with, half being the one the model was fitted with.
     float attack() const;
     void setAttack(float attack);
+
+    //! How much of the strike's level follows velocity, one being the reference's own law.
+    float velocitySensitivity() const;
+    void setVelocitySensitivity(float sensitivity);
     float lpfCutoff() const;
     void setLpfCutoff(float cutoff);
     float hpfCutoff() const;
@@ -131,6 +135,7 @@ class PianoSynthV3Device : public Device
     float m_richness { 0.7f };
     float m_doubleDecay { 0.5f };
     float m_attack { 0.5f };
+    float m_velocitySensitivity { 1.0f };
     float m_lpfCutoff { 1.0f };
     float m_hpfCutoff { 0.0f };
     float m_releaseTime { 0.15f };

src/domain/dsp/modal_piano_string_v3.cpp

@@ -395,7 +395,12 @@ void ModalPianoStringV3::trigger(uint8_t note, float velocity, const Settings &
     // Velocity squares, matching the eight and a half decibels the reference gains
     // between velocity 64 and 100.
     const double norm = sumOfSquares > 0.0 ? 1.0 / std::sqrt(sumOfSquares) : 0.0;
-    m_gain = norm * vel * vel * keyLevel(note);
+    // Velocity is squared because the reference gains eight and a half decibels between 64 and
+    // 100, and it is blended toward unity first so the player can flatten that. The blend is on
+    // the level alone: hammerCorner above still reads the velocity as struck.
+    const double sensitivity = std::clamp(static_cast<double>(settings.velocitySensitivity), 0.0, 1.0);
+    const double levelVel = (1.0 - sensitivity) + sensitivity * vel;
+    m_gain = norm * levelVel * levelVel * keyLevel(note);
 
     // A short ramp over the strike, long in the bass and brief at the top, so that the
     // modes do not all land on one sample. It is what an attack time is measured as.

src/domain/dsp/modal_piano_string_v3.hpp

@@ -74,6 +74,11 @@ class ModalPianoStringV3 : public DspComponent
         // patch that leaves it alone is unchanged; below that the note arrives more abruptly, above
         // it the hammer is felt rather than heard.
         float attack { 0.5f };
+        // How much of the strike's level follows velocity. One is the whole range, which is what
+        // the reference was measured at; nothing holds every note at its loudest. Only the level
+        // is blended -- the hammer still hardens with velocity, so a note played softly stays
+        // soft in tone while coming up in level, which is the point of the control.
+        float velocitySensitivity { 1.0f };
     };
 
     // Partials of the note itself, before the unison pairs are added. The reference has

src/unit_tests/piano_synth_v3_test/piano_synth_v3_test.cpp

@@ -929,6 +929,66 @@ double partialMagnitude(const std::vector<double> & buffer, uint8_t note, int pa
 
 } // namespace
 
+void PianoSynthV3Test::test_velocitySensitivity_shouldFlattenTheLevelWithoutTouchingTone()
+{
+    constexpr uint8_t note = 84;
+    constexpr int sampleCount = 24000;
+
+    const auto peakAt = [](float velocity, float sensitivity) {
+        ModalPianoStringV3::Settings settings;
+        settings.velocitySensitivity = sensitivity;
+        ModalPianoStringV3 string;
+        string.setSampleRate(TestSampleRate);
+        string.trigger(note, velocity, settings);
+        double peak = 0.0;
+        for (int i = 0; i < sampleCount; i++) {
+            peak = std::max(peak, std::abs(string.nextSample()));
+        }
+        return peak;
+    };
+
+    // Full sensitivity is the reference's own law: half velocity is a quarter of the level, the
+    // eight and a half decibels the survey measured between velocity 64 and 100.
+    const double fullSoft = peakAt(0.5f, 1.0f);
+    const double fullHard = peakAt(1.0f, 1.0f);
+    QVERIFY2(std::abs(fullHard / fullSoft - 4.0) < 0.4,
+             qPrintable(QString { "Expected a factor of four, got %1" }.arg(fullHard / fullSoft)));
+
+    // Turning it down lifts the soft strike toward the loud one.
+    const double halfSoft = peakAt(0.5f, 0.5f);
+    QVERIFY2(halfSoft > fullSoft * 1.5,
+             qPrintable(QString { "Soft strike only moved from %1 to %2" }.arg(fullSoft).arg(halfSoft)));
+
+    // At nothing, velocity stops setting the level. Not to the last decimal: the hammer still
+    // hardens with velocity, and a different spectrum peaks a little differently even at the same
+    // gain -- under a decibel here, against the twelve that full sensitivity spans.
+    const double flatRatio = peakAt(0.2f, 0.0f) / peakAt(1.0f, 0.0f);
+    QVERIFY2(std::abs(flatRatio - 1.0) < 0.15,
+             qPrintable(QString { "Level still followed velocity: %1" }.arg(flatRatio)));
+
+    // And the loud end is left where it was, so the control cannot make a patch louder than the
+    // instrument's own top.
+    QVERIFY2(std::abs(peakAt(1.0f, 0.0f) / fullHard - 1.0) < 0.02,
+             qPrintable(QString { "Full velocity moved by %1" }.arg(peakAt(1.0f, 0.0f) / fullHard)));
+
+    // The tone still follows the hammer, not the blend: a soft strike stays soft in colour even
+    // when it has been brought up in level. Measured as the ninth partial against the first.
+    const auto brightness = [](float velocity, float sensitivity) {
+        ModalPianoStringV3::Settings settings;
+        settings.velocitySensitivity = sensitivity;
+        ModalPianoStringV3 string;
+        string.setSampleRate(TestSampleRate);
+        string.trigger(note, velocity, settings);
+        std::vector<double> buffer(static_cast<size_t>(sampleCount), 0.0);
+        for (int i = 0; i < sampleCount; i++) {
+            buffer[static_cast<size_t>(i)] = string.nextSample();
+        }
+        return partialMagnitude(buffer, note, 9) / partialMagnitude(buffer, note, 1);
+    };
+    QVERIFY2(std::abs(brightness(0.5f, 0.0f) / brightness(0.5f, 1.0f) - 1.0) < 0.05,
+             qPrintable(QString { "Tone moved with the blend: %1" }.arg(brightness(0.5f, 0.0f) / brightness(0.5f, 1.0f))));
+}
+
 void PianoSynthV3Test::test_pickupSign_shouldChangePhasesWithoutChangingLevel()
 {
     // MIDI 24 is single-strung in both revisions, so neither the bichord bound nor the

src/unit_tests/piano_synth_v3_test/piano_synth_v3_test.hpp

@@ -40,6 +40,7 @@ private slots:
 
     // The three corrections V3 exists for. Each is written against V2's behaviour, so each
     // fails if the V3 string is ever made to behave like the older one again.
+    void test_velocitySensitivity_shouldFlattenTheLevelWithoutTouchingTone();
     void test_pickupSign_shouldChangePhasesWithoutChangingLevel();
     void test_bichord_shouldLeaveTheLowBassSingleStrung();
     void test_unisonStandIn_shouldNotStepTheSpectrum();

src/view/controllers/piano_synth_v3_controller.cpp

@@ -153,6 +153,18 @@ void PianoSynthV3Controller::setAttack(int value)
     }
 }
 
+int PianoSynthV3Controller::velocitySensitivity() const
+{
+    return m_device ? static_cast<int>(std::round(m_device->velocitySensitivity() * Constants::uiInternalScaling())) : 0;
+}
+
+void PianoSynthV3Controller::setVelocitySensitivity(int value)
+{
+    if (m_device) {
+        m_device->setVelocitySensitivity(static_cast<float>(value) / Constants::uiInternalScaling());
+    }
+}
+
 int PianoSynthV3Controller::lpfCutoff() const
 {
     return m_device ? static_cast<int>(std::round(m_device->lpfCutoff() * Constants::uiInternalScaling())) : 0;
@@ -212,6 +224,7 @@ void PianoSynthV3Controller::requestSettings()
     emit richnessChanged();
     emit doubleDecayChanged();
     emit attackChanged();
+    emit velocitySensitivityChanged();
     emit lpfCutoffChanged();
     emit hpfCutoffChanged();
     emit releaseTimeChanged();

src/view/controllers/piano_synth_v3_controller.hpp

@@ -36,6 +36,7 @@ class PianoSynthV3Controller : public DeviceController
     Q_PROPERTY(int richness READ richness WRITE setRichness NOTIFY richnessChanged)
     Q_PROPERTY(int doubleDecay READ doubleDecay WRITE setDoubleDecay NOTIFY doubleDecayChanged)
     Q_PROPERTY(int attack READ attack WRITE setAttack NOTIFY attackChanged)
+    Q_PROPERTY(int velocitySensitivity READ velocitySensitivity WRITE setVelocitySensitivity NOTIFY velocitySensitivityChanged)
     Q_PROPERTY(int lpfCutoff READ lpfCutoff WRITE setLpfCutoff NOTIFY lpfCutoffChanged)
     Q_PROPERTY(int hpfCutoff READ hpfCutoff WRITE setHpfCutoff NOTIFY hpfCutoffChanged)
     Q_PROPERTY(int releaseTime READ releaseTime WRITE setReleaseTime NOTIFY releaseTimeChanged)
@@ -64,6 +65,8 @@ class PianoSynthV3Controller : public DeviceController
     void setRichness(int value);
     int doubleDecay() const;
     int attack() const;
+    int velocitySensitivity() const;
+    void setVelocitySensitivity(int value);
     void setDoubleDecay(int value);
     void setAttack(int value);
     int lpfCutoff() const;
@@ -88,6 +91,7 @@ class PianoSynthV3Controller : public DeviceController
     void richnessChanged();
     void doubleDecayChanged();
     void attackChanged();
+    void velocitySensitivityChanged();
     void lpfCutoffChanged();
     void hpfCutoffChanged();
     void releaseTimeChanged();

src/view/qml/Dialogs/PianoSynthV3Dialog_Hammer.qml

@@ -49,6 +49,15 @@ ColumnLayout {
         onMoved: v => pianoSynthV3Controller.attack = v
         Layout.fillWidth: true
     }
+    Knob {
+        // Full is the reference's own law, where the level follows velocity squared. Turning it
+        // down lifts the softer strikes toward the loud ones without touching their tone, which
+        // is what makes the top of the keyboard playable without hammering it.
+        label: qsTr("Velocity Sensitivity")
+        value: pianoSynthV3Controller.velocitySensitivity
+        onMoved: v => pianoSynthV3Controller.velocitySensitivity = v
+        Layout.fillWidth: true
+    }
     Knob {
         label: qsTr("Richness")
         value: pianoSynthV3Controller.richness