MIDI import: optimization for speed

mscore/importmidi.cpp

@@ -77,8 +77,8 @@ void cleanUpMidiEvents(std::multimap<int, MTrack> &tracks)
             for (auto chordIt = mtrack.chords.begin(); chordIt != mtrack.chords.end(); ) {
                   MidiChord &ch = chordIt->second;
                   for (auto noteIt = ch.notes.begin(); noteIt != ch.notes.end(); ) {
-                        if ((noteIt->len < MChord::minAllowedDuration())
-                                    || (!reduce && noteIt->len < raster / 2)) {
+                        if ((noteIt->offTime - chordIt->first < MChord::minAllowedDuration())
+                                    || (!reduce && noteIt->offTime - chordIt->first < raster / 2)) {
                               noteIt = ch.notes.erase(noteIt);
                               continue;
                               }
@@ -93,6 +93,57 @@ void cleanUpMidiEvents(std::multimap<int, MTrack> &tracks)
             }
       }
 
+
+#ifdef QT_DEBUG
+
+bool doNotesOverlap(const MTrack &track)
+      {
+      const auto &chords = track.chords;
+      for (auto i1 = chords.begin(); i1 != chords.end(); ++i1) {
+            const auto &chord1 = i1->second;
+            for (const auto &note1: chord1.notes) {
+                  for (auto i2 = std::next(i1); i2 != chords.end(); ++i2) {
+                        if (i2->first >= note1.offTime)
+                              break;
+                        const auto &chord2 = i2->second;
+                        if (chord1.voice != chord2.voice)
+                              continue;
+                        for (const auto &note2: chord2.notes) {
+                              if (note2.pitch != note1.pitch)
+                                    continue;
+                              return true;
+                              }
+                        }
+                  }
+            }
+      return false;
+      }
+
+bool doNotesOverlap(const std::multimap<int, MTrack> &tracks)
+      {
+      bool result = false;
+      for (const auto &track: tracks)
+            result = doNotesOverlap(track.second);
+      return result;
+      }
+
+bool noTooShortNotes(const std::multimap<int, MTrack> &tracks)
+      {
+      for (const auto &track: tracks) {
+            const auto &chords = track.second.chords;
+            for (const auto &chord: chords) {
+                  for (const auto &note: chord.second.notes) {
+                        if (note.offTime - chord.first < MChord::minAllowedDuration())
+                              return false;
+                        }
+                  }
+            }
+      return true;
+      }
+
+#endif
+
+
 void quantizeAllTracks(std::multimap<int, MTrack> &tracks,
                        TimeSigMap *sigmap,
                        const ReducedFraction &lastTick)
@@ -105,6 +156,11 @@ void quantizeAllTracks(std::multimap<int, MTrack> &tracks,
             opers.setCurrentTrack(mtrack.indexOfOperation);
             opers.adaptForPercussion(mtrack.indexOfOperation, mtrack.mtrack->drumTrack());
             mtrack.tuplets = MidiTuplet::findAllTuplets(mtrack.chords, sigmap, lastTick);
+
+            Q_ASSERT_X(!doNotesOverlap(track.second),
+                       "quantizeAllTracks",
+                       "There are overlapping notes of the same voice that is incorrect");
+
             Quantize::quantizeChords(mtrack.chords, mtrack.tuplets, sigmap);
             }
       }
@@ -387,7 +443,7 @@ void MTrack::processPendingNotes(QList<MidiChord> &midiChords,
             ReducedFraction len = nextChordTick - tick;
             if (len <= ReducedFraction(0, 1))
                   break;
-            len = MChord::findMinDuration(midiChords, len);
+            len = MChord::findMinDuration(tick, midiChords, len);
             Measure* measure = score->tick2measure(tick.ticks());
             len = splitDurationOnBarBoundary(len, tick, measure);
 
@@ -418,14 +474,12 @@ void MTrack::processPendingNotes(QList<MidiChord> &midiChords,
                   MidiChord& midiChord = midiChords[k];
                   setMusicNotesFromMidi(score, midiChord.notes, startChordTick,
                                         len, chord, tick, drumset, useDrumset);
-                  if (!midiChord.notes.empty() && midiChord.notes.first().len <= len) {
+                  if (!midiChord.notes.empty() && midiChord.notes.first().offTime - tick <= len) {
                         midiChords.removeAt(k);
                         --k;
                         continue;
                         }
                   setTies(chord, score, midiChord.notes);
-                  for (auto &midiNote: midiChord.notes)
-                        midiNote.len -= len;
                   }
             startChordTick += len;
             }
@@ -561,7 +615,7 @@ std::multimap<int, MTrack> createMTrackList(ReducedFraction &lastTick,
                         MidiNote  n;
                         n.pitch    = pitch;
                         n.velo     = e.velo();
-                        n.len      = len;
+                        n.offTime  = tick + len;
 
                         MidiChord c;
                         c.notes.push_back(n);
@@ -860,54 +914,6 @@ QList<TrackMeta> getTracksMeta(const QList<MTrack> &tracks,
       return tracksMeta;
       }
 
-
-#ifdef QT_DEBUG
-
-bool doNotesOverlap(const std::multimap<int, MTrack> &tracks)
-      {
-      for (const auto &track: tracks) {
-            const auto &chords = track.second.chords;
-            for (auto it = chords.begin(); it != chords.end(); ++it) {
-                  const auto &firstChord = it->second;
-                  const auto &firstOnTime = it->first;
-                  for (const auto &note1: firstChord.notes) {
-                        auto ii = std::next(it);
-                        for (; ii != chords.end(); ++ii) {
-                              const auto &secondChord = ii->second;
-                              if (firstChord.voice != secondChord.voice)
-                                    continue;
-                              const auto &secondOnTime = ii->first;
-                              for (const auto &note2: secondChord.notes) {
-                                    if (note2.pitch != note1.pitch)
-                                          continue;
-                                    if (secondOnTime >= (firstOnTime + note1.len))
-                                          continue;
-                                    return true;
-                                    }
-                              }
-                        }
-                  }
-            }
-      return false;
-      }
-
-bool noTooShortNotes(const std::multimap<int, MTrack> &tracks)
-      {
-      for (const auto &track: tracks) {
-            const auto &chords = track.second.chords;
-            for (const auto &chord: chords) {
-                  for (const auto &note: chord.second.notes) {
-                        if (note.len < MChord::minAllowedDuration())
-                              return false;
-                        }
-                  }
-            }
-      return true;
-      }
-
-#endif
-
-
 void convertMidi(Score *score, const MidiFile *mf)
       {
       ReducedFraction lastTick;
@@ -919,14 +925,15 @@ void convertMidi(Score *score, const MidiFile *mf)
       MChord::removeOverlappingNotes(tracks);
 
       Q_ASSERT_X(!doNotesOverlap(tracks),
-                 "convertMidi:", "There are overlapping notes of the same voice that is incorrect");
+                 "convertMidi", "There are overlapping notes of the same voice that is incorrect");
 
       quantizeAllTracks(tracks, sigmap, lastTick);
 
       Q_ASSERT_X(!doNotesOverlap(tracks),
-                 "convertMidi:", "There are overlapping notes of the same voice that is incorrect");
+                 "convertMidi", "There are overlapping notes of the same voice that is incorrect");
+
       Q_ASSERT_X(noTooShortNotes(tracks),
-                 "convertMidi:", "There are notes of length < min allowed duration");
+                 "convertMidi", "There are notes of length < min allowed duration");
 
       MChord::mergeChordsWithEqualOnTimeAndVoice(tracks);
       LRHand::splitIntoLeftRightHands(tracks);

mscore/importmidi_chord.cpp

@@ -17,14 +17,14 @@ const ReducedFraction& minAllowedDuration()
       return minDuration;
       }
 
-ReducedFraction maxNoteLen(const QList<MidiNote> &notes)
+ReducedFraction maxNoteOffTime(const QList<MidiNote> &notes)
       {
-      ReducedFraction maxLen(0, 1);
+      ReducedFraction maxOffTime(0, 1);
       for (const auto &note: notes) {
-            if (note.len > maxLen)
-                  maxLen = note.len;
+            if (note.offTime > maxOffTime)
+                  maxOffTime = note.offTime;
             }
-      return maxLen;
+      return maxOffTime;
       }
 
 // remove overlapping notes with the same pitch
@@ -33,32 +33,31 @@ void removeOverlappingNotes(std::multimap<int, MTrack> &tracks)
       {
       for (auto &track: tracks) {
             auto &chords = track.second.chords;
-            for (auto it = chords.begin(); it != chords.end(); ++it) {
-                  auto &firstChord = it->second;
-                  const auto &firstOnTime = it->first;
-                  for (auto &note1: firstChord.notes) {
-                        auto ii = std::next(it);
-                        for (; ii != chords.end(); ++ii) {
-                              auto &secondChord = ii->second;
-                              if (firstChord.voice != secondChord.voice)
+            for (auto i1 = chords.begin(); i1 != chords.end(); ++i1) {
+                  auto &chord1 = i1->second;
+                  const auto &onTime1 = i1->first;
+                  for (auto &note1: chord1.notes) {
+                        for (auto i2 = std::next(i1); i2 != chords.end(); ++i2) {
+                              const auto &onTime2 = i2->first;
+                              if (onTime2 >= note1.offTime)
+                                    break;
+                              auto &chord2 = i2->second;
+                              if (chord1.voice != chord2.voice)
                                     continue;
-                              const auto &secondOnTime = ii->first;
-                              for (auto &note2: secondChord.notes) {
+                              for (auto &note2: chord2.notes) {
                                     if (note2.pitch != note1.pitch)
                                           continue;
-                                    if (secondOnTime >= (firstOnTime + note1.len))
-                                          continue;
                                     qDebug("Midi import: overlapping events: %d+%d %d+%d",
-                                           firstOnTime.ticks(), note1.len.ticks(),
-                                           secondOnTime.ticks(), note2.len.ticks());
-                                    note1.len = secondOnTime - firstOnTime;
-                                    ii = std::prev(chords.end());
+                                           onTime1.ticks(), note1.offTime.ticks(),
+                                           onTime2.ticks(), note2.offTime.ticks());
+                                    note1.offTime = onTime2;
+                                    i2 = std::prev(chords.end());
                                     break;
                                     }
                               }
-                        if (note1.len <= ReducedFraction(0, 1)) {
-                              qDebug("Midi import: duration <= 0: drop note at %d",
-                                     firstOnTime.ticks());
+                        if (note1.offTime <= ReducedFraction(0, 1)) {
+                              qDebug("removeOverlappingNotes: duration <= 0: drop note at %d",
+                                     onTime1.ticks());
                               continue;
                               }
                         }
@@ -139,7 +138,7 @@ void collectChords(std::multimap<int, MTrack> &tracks)
                   const auto &note = it->second.notes[0];
 
                               // short events with len < minAllowedDuration must be cleaned up
-                  Q_ASSERT_X(note.len >= minAllowedDuration(),
+                  Q_ASSERT_X(note.offTime - it->first >= minAllowedDuration(),
                              "MChord: collectChords", "Note length is less than min allowed duration");
 
                   if (it->first <= currentChordStart + curThreshTime) {
@@ -156,21 +155,21 @@ void collectChords(std::multimap<int, MTrack> &tracks)
                                           && curThreshTime == threshTime) {
                                     curThreshTime += threshExtTime;
                                     }
-                              if (it->first + note.len > maxOffTime)
-                                    maxOffTime = it->first + note.len;
+                              if (note.offTime > maxOffTime)
+                                    maxOffTime = note.offTime;
                               it = chords.erase(it);
                               continue;
                               }
                         }
                   currentChordStart = it->first;
-                  maxOffTime = currentChordStart + note.len;
+                  maxOffTime = note.offTime;
                   curThreshTime = threshTime;
                   ++it;
                   }
 
             Q_ASSERT_X(areOnTimeValuesDifferent(chords),
-                       "MChord: collectChords", "onTime values of chords are equal "
-                                                "but should be different");
+                       "MChord: collectChords",
+                       "onTime values of chords are equal but should be different");
             }
       }
 
@@ -195,12 +194,12 @@ void sortNotesByLength(std::multimap<ReducedFraction, MidiChord> &chords)
       struct {
             bool operator()(const MidiNote &note1, const MidiNote &note2)
                   {
-                  return note1.len < note2.len;
+                  return note1.offTime < note2.offTime;
                   }
             } lenSort;
 
       for (auto &chordEvent: chords) {
-                        // in each chord sort notes by pitches
+                        // in each chord sort notes by lengths
             auto &notes = chordEvent.second.notes;
             qSort(notes.begin(), notes.end(), lenSort);
             }
@@ -219,13 +218,13 @@ void splitUnequalChords(std::multimap<int, MTrack> &tracks)
             for (auto &chordEvent: chords) {
                   auto &chord = chordEvent.second;
                   auto &notes = chord.notes;
-                  ReducedFraction len;
+                  ReducedFraction offTime;
                   for (auto it = notes.begin(); it != notes.end(); ) {
                         if (it == notes.begin())
-                              len = it->len;
+                              offTime = it->offTime;
                         else {
-                              ReducedFraction newLen = it->len;
-                              if (newLen != len) {
+                              ReducedFraction newOffTime = it->offTime;
+                              if (newOffTime != offTime) {
                                     MidiChord newChord(chord);
                                     newChord.notes.clear();
                                     for (int j = it - notes.begin(); j > 0; --j)
@@ -243,14 +242,16 @@ void splitUnequalChords(std::multimap<int, MTrack> &tracks)
             }
       }
 
-ReducedFraction findMinDuration(const QList<MidiChord> &midiChords,
+ReducedFraction findMinDuration(const ReducedFraction &onTime,
+                                const QList<MidiChord> &midiChords,
                                 const ReducedFraction &length)
       {
       ReducedFraction len = length;
       for (const auto &chord: midiChords) {
             for (const auto &note: chord.notes) {
-                  if ((note.len < len) && (note.len != ReducedFraction(0, 1)))
-                        len = note.len;
+                  if ((note.offTime - onTime < len)
+                              && (note.offTime - onTime != ReducedFraction(0, 1)))
+                        len = note.offTime - onTime;
                   }
             }
       return len;

mscore/importmidi_chord.h

@@ -12,7 +12,8 @@ class MidiNote {
    public:
       int pitch;
       int velo;
-      ReducedFraction len;
+      ReducedFraction offTime;
+      ReducedFraction quantizedOffTime = {-1, 1};     // invalid
       Tie* tie = nullptr;
       bool staccato = false;
       };
@@ -21,8 +22,8 @@ class MidiChord {
    public:
       int voice = 0;
       bool isInTuplet = false;
+      ReducedFraction quantizedOnTime = {-1, 1};      // invalid
       QList<MidiNote> notes;
-
       bool isStaccato() const
             {
             for (const auto &note: notes)
@@ -66,9 +67,10 @@ Iter findEndChordInRange(const ReducedFraction &endRangeTick,
       return it;
       }
 
-ReducedFraction maxNoteLen(const QList<MidiNote> &notes);
+ReducedFraction maxNoteOffTime(const QList<MidiNote> &notes);
 const ReducedFraction& minAllowedDuration();
-ReducedFraction findMinDuration(const QList<MidiChord> &midiChords,
+ReducedFraction findMinDuration(const ReducedFraction &onTime,
+                                const QList<MidiChord> &midiChords,
                                 const ReducedFraction &length);
 void sortNotesByPitch(std::multimap<ReducedFraction, MidiChord> &chords);
 void collectChords(std::multimap<int, MTrack> &tracks);