simple time processing optimization

when playing a song with single tempo, time calculation can be
optimized for better accuracy.

Author: pedrolcl

seqplayer.cpp

@@ -278,16 +278,18 @@ void SequencePlayer::playerLoop()
     using Clock = steady_clock;
     using TimePoint = Clock::time_point;
     static const std::type_info &beatId = typeid(BeatEvent);
+    bool useSimpleTimeProcess = m_song.simpleTimeProcess();
     int currentBar{0};
     quint64 echoTicks{0};
-    microseconds deltaTime{microseconds::zero()}, echoDelta{m_echoResolution};
+    microseconds echoDelta{m_echoResolution};
     TimePoint currentTime{Clock::now()}, nextTime{currentTime}, nextEcho{currentTime},
         startTime{currentTime};
     emit songStarted();
     QAbstractEventDispatcher* dispatcher = thread()->eventDispatcher();
     QEventLoop::ProcessEventsFlags eventFilter = QEventLoop::ExcludeUserInputEvents;
     dispatcher->processEvents(eventFilter);
     m_songPositionTicks = 0;
+    //qDebug() << "using simple time process: " << useSimpleTimeProcess
 
 #ifdef WIN32
     timeBeginPeriod(1);
@@ -303,9 +305,12 @@ void SequencePlayer::playerLoop()
                 }
             }
             if (ev->delta() > 0) {
-                deltaTime = m_song.deltaTimeOfEvent(ev);
+                if (useSimpleTimeProcess) {
+                    nextTime = startTime + m_song.timeOfEvent(ev);
+                } else {
+                    nextTime = currentTime + m_song.deltaTimeOfEvent(ev);
+                }
                 echoDelta = m_song.timeOfTicks(m_echoResolution);
-                nextTime = currentTime + deltaTime;
                 nextEcho = currentTime + echoDelta;
                 while (nextEcho < nextTime) {
                     dispatcher->processEvents(eventFilter);

sequence.cpp

@@ -292,8 +292,8 @@ void Sequence::clear()
     m_highestMidiNote = 0;
     m_curTrack = 0;
     m_duration = 0;
-    m_initialTempo = 0;
-    m_firstTime = true;
+    m_initialTempo = 5e5;
+    m_numTempoChanges = 0;
     m_codec = nullptr;
     m_infoMap.clear();
     for(int i=0; i<MIDI_STD_CHANNELS; ++i) {
@@ -313,10 +313,9 @@ void Sequence::clear()
     m_trkChannel.clear();
     m_currentFile.clear();
     m_currentFileFull.clear();
-    while (!m_list.isEmpty()) {
-        delete m_list.takeFirst();
-    }
     m_loadingErrors.clear();
+    qDeleteAll(m_list);
+    m_list.clear();
 }
 
 bool Sequence::isEmpty()
@@ -425,6 +424,22 @@ int Sequence::errorsCount() const
     return m_loadingErrors.size();
 }
 
+qsizetype Sequence::size() const
+{
+    return m_list.size();
+}
+
+qreal Sequence::initialTempo() const
+{
+    return m_initialTempo;
+}
+
+bool Sequence::simpleTimeProcess() const
+{
+    //qDebug() << Q_FUNC_INFO << m_numTempoChanges;
+    return (m_numTempoChanges <= 1);
+}
+
 QString Sequence::duration() const
 {
     std::chrono::microseconds us = timeOfTicks(m_ticksDuration);
@@ -623,13 +638,8 @@ int Sequence::songLengthTicks() const
 void Sequence::updateTempo(qreal newTempo)
 {
     if (m_tempo != newTempo) {
-        //qDebug() << Q_FUNC_INFO << newTempo;
         m_tempo = newTempo;
         timeCalculations();
-        if (m_firstTime) {
-            m_initialTempo = newTempo;
-            m_firstTime = false;
-        };
     }
 }
 
@@ -896,6 +906,10 @@ void Sequence::smfTempoEvent(int tempo)
     if (ev->tick() == 0) {
         updateTempo(tempo);
     }
+    if (m_numTempoChanges == 0) {
+        m_initialTempo = tempo;
+    };
+    m_numTempoChanges++;
 }
 
 void Sequence::smfTimeSigEvent(int b0, int b1, int b2, int b3)
@@ -1231,6 +1245,10 @@ void Sequence::wrkTempoEvent(long time, int tempo)
     if (time == 0) {
         updateTempo(ev->tempo());
     }
+    if (m_numTempoChanges == 0) {
+        m_initialTempo = ev->tempo();
+    };
+    m_numTempoChanges++;
 }
 
 void Sequence::wrkTrackPatch(int track, int patch)

sequence.h

@@ -124,8 +124,9 @@ class Sequence : public QObject
     QString loadingErrors() const;
     int errorsCount() const;
 
-    qsizetype size() const { return m_list.size(); }
-    qreal initialTempo() const { return m_initialTempo; }
+    qsizetype size() const;
+    qreal initialTempo() const;
+    bool simpleTimeProcess() const;
     QString duration() const;
 
 signals:
@@ -293,8 +294,8 @@ public slots:
     QMap<int, int> m_trkChannel;
     QMap<QString, QString> m_infoMap;
     QList<QString> m_loadingErrors;
-    bool m_firstTime{true};
-    qreal m_initialTempo{0};
+    int m_numTempoChanges{0};
+    qreal m_initialTempo{5e5};
 };
 
 #endif // SEQUENCE_H