Merge pull request #28558 from alexpavlov96/grace_bend_midi

midi-render: implemented playback for bends to "grace note after"

Author: alexpavlov96

src/engraving/compat/midi/compatmidirender.cpp

@@ -610,7 +610,18 @@ void CompatMidiRender::createGraceNotesPlayEvents(const Score* score, const Frac
 
         on += graceDuration;
     }
-    if (na) {
+
+    bool graceBendAfter = std::any_of(gna.begin(), gna.end(), [](const Chord* graceChord) {
+        for (Note* note : graceChord->notes()) {
+            if (note->bendBack()) {
+                return true;
+            }
+        }
+
+        return false;
+    });
+
+    if (!graceBendAfter && na) {
         if (chord->dots() == 1) {
             trailtime = floor(667 * weighta);
         } else if (chord->dots() == 2) {

src/engraving/compat/midi/compatmidirenderinternal.cpp

@@ -344,12 +344,12 @@ static bool shouldProceedBend(const Note* note)
     return baseNote->lastTiedNote(false) == note;
 }
 
-static BendPlaybackInfo getBendPlaybackInfo(const GuitarBend* bend, int bendStart, int bendDuration)
+static BendPlaybackInfo getBendPlaybackInfo(const GuitarBend* bend, int bendStart, int bendDuration, bool graceBeforeBend)
 {
     BendPlaybackInfo bendInfo;
 
-    // currently ignoring diagram for grace bends
-    if (bend->type() != GuitarBendType::GRACE_NOTE_BEND) {
+    // currently ignoring diagram for "grace before" bends
+    if (!graceBeforeBend) {
         bendInfo.startTimeFactor = bend->startTimeFactor();
         bendInfo.endTimeFactor = bend->endTimeFactor();
     }
@@ -360,6 +360,71 @@ static BendPlaybackInfo getBendPlaybackInfo(const GuitarBend* bend, int bendStar
     return bendInfo;
 }
 
+static void fillBendDurations(const Note* bendStartNote, const std::unordered_set<const Note*>& currentNotes,
+                              std::unordered_map<const Note*, size_t>& durations, bool tiedToNext)
+{
+    if (!bendStartNote || currentNotes.empty()) {
+        return;
+    }
+
+    size_t bendsAmount = tiedToNext ? currentNotes.size() + 1 : currentNotes.size();
+    size_t eachBendDuration = bendStartNote->chord()->actualTicks().ticks() / bendsAmount;
+
+    for (const Note* note : currentNotes) {
+        durations.insert({ note, eachBendDuration });
+    }
+}
+
+static std::unordered_map<const Note*, size_t> getGraceNoteBendDurations(const Note* note)
+{
+    std::unordered_map<const Note*, size_t> durations;
+    const Note* bendStartNote = nullptr;
+    std::unordered_set<const Note*> currentNotes;
+
+    while (note->tieFor()) {
+        const Tie* tieFor = note->tieFor();
+        IF_ASSERT_FAILED(tieFor->endNote()) {
+            LOGE() << "cannot find tied note for note on track " << note->track() << ", tick " << note->tick().ticks();
+            return {};
+        }
+        note = tieFor->endNote();
+    }
+
+    while (note->bendFor()) {
+        const GuitarBend* bendFor = note->bendFor();
+        const Note* endNote = bendFor->endNote();
+        if (!endNote || note == endNote) {
+            LOGE() << "cannot find end bend note for note on track " << note->track() << ", tick " << note->tick().ticks();
+            return {};
+        }
+
+        if (endNote->chord()->isGraceAfter()) {
+            if (currentNotes.empty()) {
+                IF_ASSERT_FAILED(note->chord() == endNote->chord()->explicitParent()) {
+                    LOGE() << "error in filling bends midi data for note on track " << note->track() << ", tick " << note->tick().ticks();
+                    return {};
+                }
+                bendStartNote = note;
+                currentNotes.insert(bendStartNote);
+            }
+
+            if (endNote->bendFor()) {
+                currentNotes.insert(endNote);
+            }
+        } else {
+            fillBendDurations(bendStartNote, currentNotes, durations, true);
+            bendStartNote = nullptr;
+            currentNotes.clear();
+        }
+
+        note = bendFor->endNote();
+    }
+
+    fillBendDurations(bendStartNote, currentNotes, durations, false);
+
+    return durations;
+}
+
 /*
  * All consecutive tie and bend combinations are processed in a single pass, adding pitch bends where needed to ensure continuity between notes.
  *
@@ -378,8 +443,9 @@ static void collectGuitarBend(const Note* note,
         return;
     }
 
+    const auto& graceNoteBendDurations = getGraceNoteBendDurations(note);
+
     int curPitchBendSegmentStart = onTime;
-    int curPitchBendSegmentEnd = 0;
 
     int quarterOffsetFromStartNote = 0;
     int currentQuarterTones = 0;
@@ -392,22 +458,26 @@ static void collectGuitarBend(const Note* note,
 
     while (note->bendFor() || note->tieFor()) {
         const GuitarBend* bendFor = note->bendFor();
-        int duration = 0;
-        if (bendFor && bendFor->type() == GuitarBendType::GRACE_NOTE_BEND) {
-            duration = (previousChordTicks == -1) ? GRACE_BEND_DURATION : std::min(previousChordTicks / 2, GRACE_BEND_DURATION);
-        } else {
-            duration = note->chord()->actualTicks().ticks();
-        }
-        curPitchBendSegmentEnd = curPitchBendSegmentStart + duration;
-
+        int duration = note->chord()->actualTicks().ticks();
         if (bendFor) {
             const Note* endNote = bendFor->endNote();
 
             if (!endNote) {
                 return;
             }
 
-            BendPlaybackInfo bendPlaybackInfo = getBendPlaybackInfo(bendFor, curPitchBendSegmentStart, duration);
+            bool graceBeforeBend = false;
+            if (note->chord()->isGraceBefore() && bendFor) {
+                Note* endNote = bendFor->endNote();
+                if (endNote && endNote->noteType() == NoteType::NORMAL) {
+                    duration = (previousChordTicks == -1) ? GRACE_BEND_DURATION : std::min(previousChordTicks / 2, GRACE_BEND_DURATION);
+                    graceBeforeBend = true;
+                }
+            } else if (muse::contains(graceNoteBendDurations, note)) {
+                duration = graceNoteBendDurations.at(note);
+            }
+
+            BendPlaybackInfo bendPlaybackInfo = getBendPlaybackInfo(bendFor, curPitchBendSegmentStart, duration, graceBeforeBend);
             double initialPitchBendValue = quarterOffsetFromStartNote / 2.0;
 
             if (bendPlaybackInfo.startTick > curPitchBendSegmentStart) {
@@ -435,7 +505,7 @@ static void collectGuitarBend(const Note* note,
             pitchWheelRenderer.addPitchWheelFunction(pitchWheelSquareFunc, channel, note->staffIdx(), effect);
             quarterOffsetFromStartNote += currentQuarterTones;
 
-            if (bendPlaybackInfo.endTick < curPitchBendSegmentEnd) {
+            if (bendPlaybackInfo.endTick < curPitchBendSegmentStart + duration) {
                 addConstPitchWheel(bendPlaybackInfo.endTick, quarterOffsetFromStartNote / 2.0, pitchWheelRenderer, channel,
                                    note->staffIdx(),
                                    effect);
@@ -447,7 +517,7 @@ static void collectGuitarBend(const Note* note,
 
             note = endNote;
         } else {
-            if (note->bendBack()) {
+            if (!note->isGrace() && note->bendBack()) {
                 addConstPitchWheel(note->tick().ticks(), quarterOffsetFromStartNote / 2.0, pitchWheelRenderer, channel,
                                    note->staffIdx(), effect);
             }
@@ -459,10 +529,10 @@ static void collectGuitarBend(const Note* note,
             }
         }
 
-        curPitchBendSegmentStart = curPitchBendSegmentEnd;
+        curPitchBendSegmentStart += duration;
     }
 
-    if (note->bendBack()) {
+    if (!note->isGrace() && note->bendBack()) {
         addConstPitchWheel(note->tick().ticks(), quarterOffsetFromStartNote / 2.0, pitchWheelRenderer, channel, note->staffIdx(), effect);
     }
 }