Introduce configurable pedal release gap for VST and MIDI engines

Author: rmcat

src/engraving/compat/midi/compatmidirenderinternal.cpp

@@ -58,6 +58,7 @@
 #include "dom/segment.h"
 #include "dom/staff.h"
 #include "dom/stafftextbase.h"
+#include "dom/tempo.h"
 #include "dom/swing.h"
 #include "dom/tie.h"
 #include "dom/trill.h"
@@ -1468,6 +1469,8 @@ void CompatMidiRendererInternal::doRenderSpanners(EventsHolder& events, Spanner*
     if (s->isPedal()) {
         PedalEvent lastEvent;
 
+        // TODO: pedalEventList is always empty here, so consecutive-pedal gap checks below never fire.
+        // The list should likely be accumulated across spanners.
         if (!pedalEventList.empty()) {
             lastEvent = pedalEventList.back();
         } else {
@@ -1476,14 +1479,20 @@ void CompatMidiRendererInternal::doRenderSpanners(EventsHolder& events, Spanner*
 
         int st = s->tick().ticks();
 
+        int gapTicks = 1;
+        if (MScore::pedalReleaseGapMs > 0) {
+            double bps = score->tempomap()->multipliedTempo(st).val;
+            gapTicks = std::max(1, static_cast<int>((1000LL * MScore::pedalReleaseGapMs * bps * Constants::DIVISION) / 1000000));
+        }
+
         if (!lastEvent.on && lastEvent.tick >= (st + 2)) {
             pedalEventList.emplace(pedalEventList.cend() - 1,
-                                   st + (2 - MScore::pedalEventsMinTicks), false, staffIdx);
+                                   st + (2 - gapTicks), false, staffIdx);
         }
         int a = st + 2;
         pedalEventList.emplace_back(a, true, staffIdx);
 
-        int t = s->tick2().ticks() + (2 - MScore::pedalEventsMinTicks);
+        int t = s->tick2().ticks() + (2 - gapTicks);
         if (!score->repeatList().empty()) {
             const RepeatSegment& lastRepeat = *score->repeatList().back();
             if (t > lastRepeat.utick + lastRepeat.len()) {

src/engraving/dom/mscore.cpp

@@ -50,7 +50,7 @@ double MScore::horizontalPageGapOdd = 3.5 * DPMM;
 
 bool MScore::warnPitchRange;
 bool MScore::warnGuitarBends;
-int MScore::pedalEventsMinTicks;
+int MScore::pedalReleaseGapMs;
 
 double MScore::nudgeStep;
 double MScore::nudgeStep10;

src/engraving/dom/mscore.h

@@ -196,7 +196,7 @@ class MScore
 
     static bool warnPitchRange;
     static bool warnGuitarBends;
-    static int pedalEventsMinTicks;
+    static int pedalReleaseGapMs;
 
     static double nudgeStep;
     static double nudgeStep10;

src/engraving/engravingmodule.cpp

@@ -252,7 +252,7 @@ void EngravingModule::onInit(const IApplication::RunMode&)
 
     MScore::warnPitchRange      = true;
     MScore::warnGuitarBends     = true;
-    MScore::pedalEventsMinTicks = 1;
+    MScore::pedalReleaseGapMs = 0;
 
     Drumset::initDrumset();
     FiguredBass::readConfigFile(String());

src/engraving/playback/metaparsers/internal/spannersmetaparser.cpp

@@ -30,7 +30,9 @@
 #include "dom/tempo.h"
 
 #include "playback/utils/pitchutils.h"
+#include "playback/utils/arrangementutils.h"
 #include "playback/filters/spannerfilter.h"
+#include "dom/mscore.h"
 
 using namespace mu::engraving;
 using namespace muse;
@@ -142,6 +144,16 @@ void SpannersMetaParser::doParse(const EngravingItem* item, const RenderingConte
         return;
     }
 
+    int durationTicks = overallDurationTicks;
+
+    if (spanner->type() == ElementType::PEDAL) {
+        int gapTicks = 1;
+        if (MScore::pedalReleaseGapMs > 0) {
+            gapTicks = std::max(1, ticksFromTempoAndDuration(spannerCtx.beatsPerSecond.val, MScore::pedalReleaseGapMs * 1000));
+        }
+        durationTicks = std::max(1, overallDurationTicks - gapTicks);
+    }
+
     mpe::ArticulationMeta articulationMeta;
     articulationMeta.type = type;
     articulationMeta.pattern = pattern;
@@ -150,7 +162,7 @@ void SpannersMetaParser::doParse(const EngravingItem* item, const RenderingConte
     articulationMeta.overallDynamicChangesRange = overallDynamicRange;
     articulationMeta.overallDuration = durationFromStartAndTicks(spannerCtx.score,
                                                                  spannerCtx.nominalPositionStartTick,
-                                                                 overallDurationTicks,
+                                                                 durationTicks,
                                                                  spannerCtx.positionTickOffset);
 
     appendArticulationData(std::move(articulationMeta), result);

src/notation/inotationconfiguration.h

@@ -207,6 +207,10 @@ class INotationConfiguration : MODULE_GLOBAL_INTERFACE
     virtual void setNotePlayDurationMilliseconds(int durationMs) = 0;
     virtual muse::async::Channel<int> notePlayDurationMillisecondsChanged() const = 0;
 
+    virtual int pedalReleaseGapMs() const = 0;
+    virtual void setPedalReleaseGapMs(int ms) = 0;
+    virtual muse::async::Channel<int> pedalReleaseGapMsChanged() const = 0;
+
     virtual void setTemplateModeEnabled(std::optional<bool> enabled) = 0;
     virtual void setTestModeEnabled(std::optional<bool> enabled) = 0;
 

src/notation/internal/notationconfiguration.cpp

@@ -92,6 +92,7 @@ static const Settings::Key IS_CANVAS_ORIENTATION_VERTICAL_KEY(module_name, "ui/c
 static const Settings::Key COLOR_NOTES_OUTSIDE_OF_USABLE_PITCH_RANGE(module_name, "score/note/warnPitchRange");
 static const Settings::Key WARN_GUITAR_BENDS(module_name, "score/note/warnGuitarBends");
 static const Settings::Key REALTIME_DELAY(module_name, "io/midi/realtimeDelay");
+static const Settings::Key PEDAL_RELEASE_GAP_MS(module_name, "application/playback/pedalReleaseGapMs");
 static const Settings::Key USE_MIDI_VELOCITY_AND_DURATION_DURING_NOTE_INPUT(module_name,
                                                                             "io/midi/useMidiVelocityAndDurationDuringNoteInput");
 static const Settings::Key NOTE_DEFAULT_PLAY_DURATION(module_name, "score/note/defaultPlayDuration");
@@ -309,6 +310,14 @@ void NotationConfiguration::init()
         m_delayBetweenNotesInRealTimeModeMillisecondsChanged.send(val.toInt());
     });
 
+    settings()->setDefaultValue(PEDAL_RELEASE_GAP_MS, Val(0));
+    settings()->setDescription(PEDAL_RELEASE_GAP_MS, muse::trc("notation", "Pedal release gap for playback (in milliseconds)"));
+    settings()->setCanBeManuallyEdited(PEDAL_RELEASE_GAP_MS, true, Val(0));
+    settings()->valueChanged(PEDAL_RELEASE_GAP_MS).onReceive(this, [this](const Val& val) {
+        mu::engraving::MScore::pedalReleaseGapMs = val.toInt();
+        m_pedalReleaseGapMsChanged.send(val.toInt());
+    });
+
     settings()->setDefaultValue(USE_MIDI_VELOCITY_AND_DURATION_DURING_NOTE_INPUT, Val(true));
     settings()->valueChanged(USE_MIDI_VELOCITY_AND_DURATION_DURING_NOTE_INPUT).onReceive(this, [this](const Val& val) {
         m_useMidiVelocityAndDurationDuringNoteInputChanged.send(val.toBool());
@@ -340,6 +349,7 @@ void NotationConfiguration::init()
 
     mu::engraving::MScore::warnPitchRange = colorNotesOutsideOfUsablePitchRange();
     mu::engraving::MScore::warnGuitarBends = warnGuitarBends();
+    mu::engraving::MScore::pedalReleaseGapMs = settings()->value(PEDAL_RELEASE_GAP_MS).toInt();
 
     // Restore stored grid size values
     mu::engraving::MScore::setHRaster(settings()->value(HORIZONTAL_GRID_SIZE_KEY).toInt());
@@ -987,6 +997,21 @@ async::Channel<int> NotationConfiguration::delayBetweenNotesInRealTimeModeMillis
     return m_delayBetweenNotesInRealTimeModeMillisecondsChanged;
 }
 
+int NotationConfiguration::pedalReleaseGapMs() const
+{
+    return settings()->value(PEDAL_RELEASE_GAP_MS).toInt();
+}
+
+void NotationConfiguration::setPedalReleaseGapMs(int ms)
+{
+    settings()->setSharedValue(PEDAL_RELEASE_GAP_MS, Val(ms));
+}
+
+async::Channel<int> NotationConfiguration::pedalReleaseGapMsChanged() const
+{
+    return m_pedalReleaseGapMsChanged;
+}
+
 bool NotationConfiguration::useMidiVelocityAndDurationDuringNoteInput() const
 {
     return settings()->value(USE_MIDI_VELOCITY_AND_DURATION_DURING_NOTE_INPUT).toBool();

src/notation/internal/notationconfiguration.h

@@ -209,6 +209,10 @@ class NotationConfiguration : public INotationConfiguration, public muse::async:
     void setNotePlayDurationMilliseconds(int durationMs) override;
     muse::async::Channel<int> notePlayDurationMillisecondsChanged() const override;
 
+    int pedalReleaseGapMs() const override;
+    void setPedalReleaseGapMs(int ms) override;
+    muse::async::Channel<int> pedalReleaseGapMsChanged() const override;
+
     void setTemplateModeEnabled(std::optional<bool> enabled) override;
     void setTestModeEnabled(std::optional<bool> enabled) override;
 
@@ -261,6 +265,7 @@ class NotationConfiguration : public INotationConfiguration, public muse::async:
     muse::async::Channel<bool> m_warnGuitarBendsChanged;
     muse::async::Channel<int> m_delayBetweenNotesInRealTimeModeMillisecondsChanged;
     muse::async::Channel<int> m_notePlayDurationMillisecondsChanged;
+    muse::async::Channel<int> m_pedalReleaseGapMsChanged;
     muse::async::Channel<bool> m_useMidiVelocityAndDurationDuringNoteInputChanged;
     muse::async::Channel<std::string> m_styleFileImportPathChanged;
     muse::async::Notification m_isPlayRepeatsChanged;

src/notation/internal/notationplayback.cpp

@@ -115,6 +115,10 @@ void NotationPlayback::init()
         }
     });
 
+    configuration()->pedalReleaseGapMsChanged().onReceive(this, [this](int) {
+        m_playbackModel.reload();
+    });
+
     score()->loopBoundaryTickChanged().onReceive(this, [this](LoopBoundaryType, unsigned) {
         updateLoopBoundaries();
     });

src/notation/tests/mocks/notationconfigurationmock.h

@@ -195,6 +195,10 @@ class NotationConfigurationMock : public INotationConfiguration
     MOCK_METHOD(void, setNotePlayDurationMilliseconds, (int), (override));
     MOCK_METHOD((muse::async::Channel<int>), notePlayDurationMillisecondsChanged, (), (const, override));
 
+    MOCK_METHOD(int, pedalReleaseGapMs, (), (const, override));
+    MOCK_METHOD(void, setPedalReleaseGapMs, (int), (override));
+    MOCK_METHOD((muse::async::Channel<int>), pedalReleaseGapMsChanged, (), (const, override));
+
     MOCK_METHOD(void, setTemplateModeEnabled, (std::optional<bool>), (override));
     MOCK_METHOD(void, setTestModeEnabled, (std::optional<bool>), (override));