Sync Lock: rename functions to make them clearer

src/engine/controls/bpmcontrol.cpp

@@ -1104,7 +1104,7 @@ void BpmControl::setTargetBeatDistance(double beatDistance) {
     m_dSyncTargetBeatDistance.setValue(beatDistance);
 }
 
-void BpmControl::setInstantaneousBpm(double instantaneousBpm) {
+void BpmControl::updateInstantaneousBpm(double instantaneousBpm) {
     m_dSyncInstantaneousBpm = instantaneousBpm;
 }
 

src/engine/controls/bpmcontrol.h

@@ -47,7 +47,7 @@ class BpmControl : public EngineControl {
     }
 
     void setTargetBeatDistance(double beatDistance);
-    void setInstantaneousBpm(double instantaneousBpm);
+    void updateInstantaneousBpm(double instantaneousBpm);
     void resetSyncAdjustment();
     double updateLocalBpm();
     /// updateBeatDistance is adjusted to include the user offset so

src/engine/sync/clock.h

@@ -5,8 +5,8 @@ class Clock {
     virtual ~Clock() = default;
 
     virtual double getBeatDistance() const = 0;
-    virtual void setMasterBeatDistance(double beatDistance) = 0;
+    virtual void updateMasterBeatDistance(double beatDistance) = 0;
 
     virtual double getBpm() const = 0;
-    virtual void setMasterBpm(double bpm) = 0;
+    virtual void updateMasterBpm(double bpm) = 0;
 };

src/engine/sync/enginesync.cpp

@@ -19,7 +19,7 @@ EngineSync::EngineSync(UserSettingsPointer pConfig)
           m_pInternalClock(new InternalClock(kInternalClockGroup, this)),
           m_pMasterSyncable(nullptr) {
     qRegisterMetaType<SyncMode>("SyncMode");
-    m_pInternalClock->setMasterBpm(124.0);
+    m_pInternalClock->updateMasterBpm(124.0);
 }
 
 EngineSync::~EngineSync() {
@@ -90,14 +90,19 @@ void EngineSync::requestSyncMode(Syncable* pSyncable, SyncMode mode) {
         pParamsSyncable = findBpmMatchTarget(pSyncable);
         if (!pParamsSyncable) {
             // We weren't able to find anything to match to, so set ourselves as the
-            // target.  That way we'll use our own params when we setMasterParams below.
+            // target.  That way we'll use our own params when we updateMasterBpm below.
             pParamsSyncable = pSyncable;
         }
     }
     // Now that all of the decks have their assignments, reinit master params if needed.
     if (pParamsSyncable) {
-        setMasterParams(pParamsSyncable);
-        pSyncable->setInstantaneousBpm(pParamsSyncable->getBpm());
+        if (kLogger.traceEnabled()) {
+            kLogger.trace()
+                    << "EngineSync::requestSyncMode setting master params from "
+                    << pParamsSyncable->getGroup();
+        }
+        reinitMasterParams(pParamsSyncable);
+        pSyncable->updateInstantaneousBpm(pParamsSyncable->getBpm());
         if (pParamsSyncable != pSyncable) {
             pSyncable->requestSync();
         }
@@ -194,6 +199,9 @@ void EngineSync::deactivateSync(Syncable* pSyncable) {
 }
 
 Syncable* EngineSync::pickMaster(Syncable* enabling_syncable) {
+    if (kLogger.traceEnabled()) {
+        kLogger.trace() << "EngineSync::pickMaster";
+    }
     if (m_pMasterSyncable &&
             m_pMasterSyncable->getSyncMode() == SYNC_MASTER_EXPLICIT &&
             m_pMasterSyncable->getBaseBpm() != 0.0) {
@@ -354,14 +362,14 @@ void EngineSync::notifyPlayingAudible(Syncable* pSyncable, bool playingAudible)
 
     if (newMaster != nullptr && newMaster != m_pMasterSyncable) {
         activateMaster(newMaster, SYNC_MASTER_SOFT);
-        setMasterParams(newMaster);
+        reinitMasterParams(newMaster);
     } else {
         Syncable* pOnlyPlayer = getUniquePlayingSyncedDeck();
         if (pOnlyPlayer) {
             // Even if we didn't change master, if there is only one player (us), then we should
-            // reinit the beat distance.
+            // update the beat distance.
             pOnlyPlayer->notifyUniquePlaying();
-            setMasterBeatDistance(pOnlyPlayer, pOnlyPlayer->getBeatDistance());
+            updateMasterBeatDistance(pOnlyPlayer, pOnlyPlayer->getBeatDistance());
         }
     }
 
@@ -380,7 +388,7 @@ void EngineSync::notifyBaseBpmChanged(Syncable* pSyncable, double bpm) {
     }
 
     if (isSyncMaster(pSyncable)) {
-        setMasterBpm(pSyncable, bpm);
+        updateMasterBpm(pSyncable, bpm);
     }
 }
 
@@ -389,7 +397,7 @@ void EngineSync::notifyRateChanged(Syncable* pSyncable, double bpm) {
         kLogger.trace() << "EngineSync::notifyRateChanged" << pSyncable->getGroup() << bpm;
     }
 
-    setMasterBpm(pSyncable, bpm);
+    updateMasterBpm(pSyncable, bpm);
 }
 
 void EngineSync::requestBpmUpdate(Syncable* pSyncable, double bpm) {
@@ -408,10 +416,10 @@ void EngineSync::requestBpmUpdate(Syncable* pSyncable, double bpm) {
 
     if (mbaseBpm != 0.0) {
         // resync to current master
-        pSyncable->setMasterParams(beatDistance, mbaseBpm, mbpm);
+        pSyncable->reinitMasterParams(beatDistance, mbaseBpm, mbpm);
     } else {
         // There is no other master, adopt this bpm as master
-        pSyncable->setMasterParams(0.0, 0.0, bpm);
+        pSyncable->reinitMasterParams(0.0, 0.0, bpm);
     }
 }
 
@@ -425,7 +433,7 @@ void EngineSync::notifyInstantaneousBpmChanged(Syncable* pSyncable, double bpm)
 
     // Do not update the master rate slider because instantaneous changes are
     // not user visible.
-    setMasterInstantaneousBpm(pSyncable, bpm);
+    updateMasterInstantaneousBpm(pSyncable, bpm);
 }
 
 void EngineSync::notifyBeatDistanceChanged(Syncable* pSyncable, double beatDistance) {
@@ -437,7 +445,7 @@ void EngineSync::notifyBeatDistanceChanged(Syncable* pSyncable, double beatDista
         return;
     }
 
-    setMasterBeatDistance(pSyncable, beatDistance);
+    updateMasterBeatDistance(pSyncable, beatDistance);
 }
 
 Syncable* EngineSync::pickNonSyncSyncTarget(EngineChannel* pDontPick) const {
@@ -564,52 +572,52 @@ double EngineSync::masterBaseBpm() const {
     return m_pInternalClock->getBaseBpm();
 }
 
-void EngineSync::setMasterBpm(Syncable* pSource, double bpm) {
-    //qDebug() << "EngineSync::setMasterBpm" << pSource << bpm;
+void EngineSync::updateMasterBpm(Syncable* pSource, double bpm) {
+    //qDebug() << "EngineSync::updateMasterBpm" << pSource << bpm;
     if (pSource != m_pInternalClock) {
-        m_pInternalClock->setMasterBpm(bpm);
+        m_pInternalClock->updateMasterBpm(bpm);
     }
     foreach (Syncable* pSyncable, m_syncables) {
         if (pSyncable == pSource ||
                 !pSyncable->isSynchronized()) {
             continue;
         }
-        pSyncable->setMasterBpm(bpm);
+        pSyncable->updateMasterBpm(bpm);
     }
 }
 
-void EngineSync::setMasterInstantaneousBpm(Syncable* pSource, double bpm) {
+void EngineSync::updateMasterInstantaneousBpm(Syncable* pSource, double bpm) {
     if (pSource != m_pInternalClock) {
-        m_pInternalClock->setInstantaneousBpm(bpm);
+        m_pInternalClock->updateInstantaneousBpm(bpm);
     }
     foreach (Syncable* pSyncable, m_syncables) {
         if (pSyncable == pSource ||
                 !pSyncable->isSynchronized()) {
             continue;
         }
-        pSyncable->setInstantaneousBpm(bpm);
+        pSyncable->updateInstantaneousBpm(bpm);
     }
 }
 
-void EngineSync::setMasterBeatDistance(Syncable* pSource, double beatDistance) {
+void EngineSync::updateMasterBeatDistance(Syncable* pSource, double beatDistance) {
     if (kLogger.traceEnabled()) {
         kLogger.trace() << "EngineSync::setMasterBeatDistance"
                         << (pSource ? pSource->getGroup() : "null")
                         << beatDistance;
     }
     if (pSource != m_pInternalClock) {
-        m_pInternalClock->setMasterBeatDistance(beatDistance);
+        m_pInternalClock->updateMasterBeatDistance(beatDistance);
     }
     foreach (Syncable* pSyncable, m_syncables) {
         if (pSyncable == pSource ||
                 !pSyncable->isSynchronized()) {
             continue;
         }
-        pSyncable->setMasterBeatDistance(beatDistance);
+        pSyncable->updateMasterBeatDistance(beatDistance);
     }
 }
 
-void EngineSync::setMasterParams(Syncable* pSource) {
+void EngineSync::reinitMasterParams(Syncable* pSource) {
     // Important note! Because of the way sync works, the new master is usually not the same
     // as the Syncable setting the master parameters (here, pSource). Notify the proper Syncable
     // so it can prepare itself.  (This is a hack to undo half/double math so that we initialize
@@ -644,17 +652,17 @@ void EngineSync::setMasterParams(Syncable* pSource) {
         bpm = baseBpm;
     }
     if (kLogger.traceEnabled()) {
-        kLogger.trace() << "BaseSyncableListener::setMasterParams, source is"
+        kLogger.trace() << "BaseSyncableListener::reinitMasterParams, source is"
                         << pSource->getGroup() << beatDistance << baseBpm << bpm;
     }
     if (pSource != m_pInternalClock) {
-        m_pInternalClock->setMasterParams(beatDistance, baseBpm, bpm);
+        m_pInternalClock->reinitMasterParams(beatDistance, baseBpm, bpm);
     }
     foreach (Syncable* pSyncable, m_syncables) {
         if (!pSyncable->isSynchronized()) {
             continue;
         }
-        pSyncable->setMasterParams(beatDistance, baseBpm, bpm);
+        pSyncable->reinitMasterParams(beatDistance, baseBpm, bpm);
     }
 }
 

src/engine/sync/enginesync.h

@@ -103,17 +103,20 @@ class EngineSync : public SyncableListener {
     double masterBaseBpm() const;
 
     /// Set the BPM on every sync-enabled Syncable except pSource.
-    void setMasterBpm(Syncable* pSource, double bpm);
+    void updateMasterBpm(Syncable* pSource, double bpm);
 
     /// Set the master instantaneous BPM on every sync-enabled Syncable except
     /// pSource.
-    void setMasterInstantaneousBpm(Syncable* pSource, double bpm);
+    void updateMasterInstantaneousBpm(Syncable* pSource, double bpm);
 
     /// Set the master beat distance on every sync-enabled Syncable except
     /// pSource.
-    void setMasterBeatDistance(Syncable* pSource, double beatDistance);
+    void updateMasterBeatDistance(Syncable* pSource, double beatDistance);
 
-    void setMasterParams(Syncable* pSource);
+    /// Initialize the master parameters using the provided syncable as the source.
+    /// This should only be called for "major" updates, like a new track or change in
+    /// master. Should not be called on every buffer callback.
+    void reinitMasterParams(Syncable* pSource);
 
     /// Iff there is a single playing syncable in sync mode, return it.
     /// This is used to initialize master params.

src/engine/sync/internalclock.cpp

@@ -103,7 +103,7 @@ double InternalClock::getBeatDistance() const {
     return m_dClockPosition / m_dBeatLength;
 }
 
-void InternalClock::setMasterBeatDistance(double beatDistance) {
+void InternalClock::updateMasterBeatDistance(double beatDistance) {
     if (kLogger.traceEnabled()) {
         kLogger.trace() << "InternalClock::setMasterBeatDistance" << beatDistance;
     }
@@ -121,7 +121,7 @@ double InternalClock::getBpm() const {
     return m_pClockBpm->get();
 }
 
-void InternalClock::setMasterBpm(double bpm) {
+void InternalClock::updateMasterBpm(double bpm) {
     if (kLogger.traceEnabled()) {
         kLogger.trace() << "InternalClock::setBpm" << bpm;
     }
@@ -132,7 +132,7 @@ void InternalClock::setMasterBpm(double bpm) {
     updateBeatLength(m_iOldSampleRate, bpm);
 }
 
-void InternalClock::setInstantaneousBpm(double bpm) {
+void InternalClock::updateInstantaneousBpm(double bpm) {
     if (kLogger.traceEnabled()) {
         kLogger.trace() << "InternalClock::setInstantaneousBpm" << bpm;
     }
@@ -143,16 +143,16 @@ void InternalClock::setInstantaneousBpm(double bpm) {
 void InternalClock::notifyMasterParamSource() {
 }
 
-void InternalClock::setMasterParams(double beatDistance, double baseBpm, double bpm) {
+void InternalClock::reinitMasterParams(double beatDistance, double baseBpm, double bpm) {
     if (kLogger.traceEnabled()) {
-        kLogger.trace() << "InternalClock::setMasterParams" << beatDistance << baseBpm << bpm;
+        kLogger.trace() << "InternalClock::reinitMasterParams" << beatDistance << baseBpm << bpm;
     }
     if (bpm <= 0.0 || baseBpm <= 0.0) {
         return;
     }
     m_dBaseBpm = baseBpm;
-    setMasterBpm(bpm);
-    setMasterBeatDistance(beatDistance);
+    updateMasterBpm(bpm);
+    updateMasterBeatDistance(beatDistance);
 }
 
 void InternalClock::slotBaseBpmChanged(double baseBpm) {
@@ -168,7 +168,7 @@ void InternalClock::slotBeatDistanceChanged(double beatDistance) {
     if (beatDistance < 0.0 || beatDistance > 1.0) {
         return;
     }
-    setMasterBeatDistance(beatDistance);
+    updateMasterBeatDistance(beatDistance);
 }
 
 void InternalClock::updateBeatLength(int sampleRate, double bpm) {
@@ -204,7 +204,7 @@ void InternalClock::updateBeatLength(int sampleRate, double bpm) {
     m_iOldSampleRate = sampleRate;
 
     // Restore the old beat distance.
-    setMasterBeatDistance(oldBeatDistance);
+    updateMasterBeatDistance(oldBeatDistance);
 }
 
 void InternalClock::onCallbackStart(int sampleRate, int bufferSize) {

src/engine/sync/internalclock.h

@@ -48,14 +48,14 @@ class InternalClock : public QObject, public Clock, public Syncable {
     }
 
     double getBeatDistance() const override;
-    void setMasterBeatDistance(double beatDistance) override;
+    void updateMasterBeatDistance(double beatDistance) override;
 
     double getBaseBpm() const override;
-    void setMasterBpm(double bpm) override;
+    void updateMasterBpm(double bpm) override;
     void notifyMasterParamSource() override;
     double getBpm() const override;
-    void setInstantaneousBpm(double bpm) override;
-    void setMasterParams(double beatDistance, double baseBpm, double bpm) override;
+    void updateInstantaneousBpm(double bpm) override;
+    void reinitMasterParams(double beatDistance, double baseBpm, double bpm) override;
 
     void onCallbackStart(int sampleRate, int bufferSize);
     void onCallbackEnd(int sampleRate, int bufferSize);

src/engine/sync/syncable.h

@@ -106,26 +106,28 @@ class Syncable {
     // current Sync Master.
     // Must never result in a call to
     // SyncableListener::notifyBeatDistanceChanged or signal loops could occur.
-    virtual void setMasterBeatDistance(double beatDistance) = 0;
+    virtual void updateMasterBeatDistance(double beatDistance) = 0;
 
+    // Update the current playback speed (not including scratch values)
+    // of the current master.
     // Must never result in a call to SyncableListener::notifyBpmChanged or
     // signal loops could occur.
-    virtual void setMasterBpm(double bpm) = 0;
+    virtual void updateMasterBpm(double bpm) = 0;
 
     // Tells a Syncable that it's going to be used as a source for master
     // params. This is a gross hack so that the SyncControl can undo its
     // half/double adjustment so bpms are initialized correctly.
     virtual void notifyMasterParamSource() = 0;
 
-    // Combines the above three calls into one, since they are often set
-    // simultaneously.  Avoids redundant recalculation that would occur by
-    // using the three calls separately.
-    virtual void setMasterParams(double beatDistance, double baseBpm, double bpm) = 0;
+    // Perform a reset of Master parameters. This function also triggers recalculation
+    // of half-double multiplier.
+    virtual void reinitMasterParams(double beatDistance, double baseBpm, double bpm) = 0;
 
+    // Update the playback speed of the master, including scratch values.
     // Must never result in a call to
     // SyncableListener::notifyInstantaneousBpmChanged or signal loops could
     // occur.
-    virtual void setInstantaneousBpm(double bpm) = 0;
+    virtual void updateInstantaneousBpm(double bpm) = 0;
 };
 
 /// SyncableListener is an interface class used by EngineSync to receive