Fix issues with half/double and Sync Lock

res/skins/LateNight/decks/deck.xml

@@ -2,7 +2,7 @@
 
   <WidgetGroup>
     <Layout>vertical</Layout>
-    <MaximumSize>,208</MaximumSize>
+    <MaximumSize>,230</MaximumSize>
     <Children>
 
       <Template src="skin:/decks/deck_singletons.xml">

res/skins/LateNight/style_classic.qss

@@ -1314,7 +1314,7 @@ WPushButton#PlayIndicator,
 WPushButton#CueDeck,
 #PlayCueMini WPushButton,
 WPushButton#LoopActivate,
-#RateControls WPushButton,
+WPushButton#RateControls WPushButton,
 WPushButton#SyncDeck,
 WPushButton#SyncLeader,
 WPushButton#SyncSampler,
@@ -1378,10 +1378,17 @@ WPushButton#SkinSettingsToggle[displayValue="0"] {
   background-color: #262626;
 }
 
+/* Orange for 'partially active' status */
+#SyncLeader[value="1"] {
+background-color: #db7700;
+}
+
 /* Red for 'active' status */
 #BeatgridControls WPushButton[value="1"],
 #RateControls WPushButton[value="1"],
-#SyncDeck[value="1"], #SyncSampler[displayValue="1"],
+#SyncDeck[value="1"],
+#SyncLeader[value="2"],
+#SyncSampler[displayValue="1"],
 WPushButton#PlayDeck[displayValue="1"],
 WPushButton#PlayDeckMini[displayValue="1"],
 WPushButton#PlaySampler[displayValue="1"],
@@ -1662,7 +1669,7 @@ WPushButton#SamplerExpand[displayValue="0"],
   }
 
 #SyncLeader {
-  background: url(skin:/classic/buttons/btn__leader_deck.svg) no-repeat center center;
+  image: url(skin:/classic/buttons/btn__leader_deck.svg) no-repeat center center;
   }
 
   #SyncSampler {

res/skins/LateNight/style_palemoon.qss

@@ -1520,7 +1520,9 @@ WPushButton#CueDeck,
 #PlayCueMini WPushButton,
 WPushButton#LoopActivate,
 WPushButton#RateControls WPushButton,
-WPushButton#SyncDeck, WPushButton#SyncSampler,
+WPushButton#SyncDeck,
+WPushButton#SyncLeader,
+WPushButton#SyncSampler,
 #MixerContainer WPushButton,
 #FxUnitContainer WPushButton,
 #Sampler WPushButton,
@@ -1631,6 +1633,8 @@ WPushButton#Reverse[pressed="true"],
 #LoopActivate[value="1"],
 #Reloop[value="1"],
 #SyncSampler[displayValue="1"],
+#SyncDeck[value="1"],
+#SyncLeader[value="2"],
 #MicTalk[value="1"], #AuxPlay[value="1"],
 #MicDucking[value="1"],
 #MicDucking[value="2"],
@@ -1649,7 +1653,7 @@ QPushButton#pushButtonAnalyze:checked {
   }
 /* dim orange for momentary controls */
 #KeyControls WPushButton[pressed="true"],
-#SyncDeck[value="1"],
+#SyncLeader[value="1"],
 WPushButton#LoopIn[pressed="true"],
 WPushButton#LoopOut[pressed="true"],
 #BeatjumpControls WPushButton[value="1"],
@@ -2103,6 +2107,10 @@ WPushButton#PlayDeck[value="0"] {
     image: url(skin:/palemoon/buttons/btn__sync_deck_active.svg) no-repeat center center;
   }
 
+#SyncLeader {
+  image: url(skin:/palemoon/buttons/btn__leader_deck.svg) no-repeat center center;
+  }
+
   #SyncSampler {
     image: url(skin:/palemoon/buttons/btn__sync_sampler.svg) no-repeat center center;
     }

src/engine/controls/bpmcontrol.cpp

@@ -536,7 +536,9 @@ double BpmControl::getBeatDistance(double dThisPosition) const {
     // we don't adjust the reported distance the track will try to adjust
     // sync against itself.
     if (kLogger.traceEnabled()) {
-        kLogger.trace() << getGroup() << "BpmControl::getBeatDistance" << dThisPosition;
+        kLogger.trace() << getGroup()
+                        << "BpmControl::getBeatDistance. dThisPosition:"
+                        << dThisPosition;
     }
     double dPrevBeat = m_pPrevBeat->get();
     double dNextBeat = m_pNextBeat->get();
@@ -560,7 +562,7 @@ double BpmControl::getBeatDistance(double dThisPosition) const {
     }
 
     if (kLogger.traceEnabled()) {
-        kLogger.trace() << getGroup() << "BpmControl::getBeatDistance"
+        kLogger.trace() << getGroup() << "BpmControl::getBeatDistance. dBeatPercentage:"
                         << dBeatPercentage << "-  offset "
                         << m_dUserOffset.getValue() << " =  "
                         << (dBeatPercentage - m_dUserOffset.getValue());

src/engine/enginemaster.cpp

@@ -369,6 +369,9 @@ void EngineMaster::processChannels(int iBufferSize) {
 
     // Do internal master sync post-processing before the other
     // channels.
+    // Note, because we call this on the internal clock first,
+    // it will have an up-to-date beatDistance, whereas the other
+    // Syncables will not.
     m_pMasterSync->onCallbackEnd(m_iSampleRate, m_iBufferSize);
 
     // After all the engines have been processed, trigger post-processing

src/engine/sync/enginesync.cpp

@@ -75,6 +75,13 @@ void EngineSync::requestSyncMode(Syncable* pSyncable, SyncMode mode) {
     default:;
     }
 
+    Syncable* pOnlyPlayer = getUniquePlayingSyncedDeck();
+    if (pOnlyPlayer) {
+        // This resets the user offset, so that if this deck gets used as the params syncable
+        // it will have that offset removed.
+        pOnlyPlayer->notifyUniquePlaying();
+    }
+
     // Second, figure out what Syncable should be used to initialize the master
     // parameters, if any. Usually this is the new master. (Note, that pointer might be null!)
     Syncable* pParamsSyncable = m_pMasterSyncable;
@@ -96,9 +103,6 @@ void EngineSync::requestSyncMode(Syncable* pSyncable, SyncMode mode) {
         }
     }
 
-    if (noPlayingFollowers() && m_pMasterSyncable) {
-        m_pMasterSyncable->notifyOnlyPlayingSyncable();
-    }
 }
 
 void EngineSync::activateFollower(Syncable* pSyncable) {
@@ -350,11 +354,15 @@ void EngineSync::notifyPlayingAudible(Syncable* pSyncable, bool playingAudible)
 
     if (newMaster != nullptr && newMaster != m_pMasterSyncable) {
         activateMaster(newMaster, SYNC_MASTER_SOFT);
-    }
-
-    if (noPlayingFollowers() && m_pMasterSyncable) {
-        m_pMasterSyncable->notifyOnlyPlayingSyncable();
-        setMasterParams(m_pMasterSyncable);
+        setMasterParams(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.
+            pOnlyPlayer->notifyUniquePlaying();
+            setMasterBeatDistance(pOnlyPlayer, pOnlyPlayer->getBeatDistance());
+        }
     }
 
     pSyncable->requestSync();
@@ -584,6 +592,11 @@ void EngineSync::setMasterInstantaneousBpm(Syncable* pSource, double bpm) {
 }
 
 void EngineSync::setMasterBeatDistance(Syncable* pSource, double beatDistance) {
+    if (kLogger.traceEnabled()) {
+        kLogger.trace() << "EngineSync::setMasterBeatDistance"
+                        << (pSource ? pSource->getGroup() : "null")
+                        << beatDistance;
+    }
     if (pSource != m_pInternalClock) {
         m_pInternalClock->setMasterBeatDistance(beatDistance);
     }
@@ -597,35 +610,68 @@ void EngineSync::setMasterBeatDistance(Syncable* pSource, double beatDistance) {
 }
 
 void EngineSync::setMasterParams(Syncable* pSource) {
-    const double beatDistance = pSource->getBeatDistance();
+    // 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
+    // based on un-multiplied bpm values).
+    pSource->notifyMasterParamSource();
+
+    double beatDistance = pSource->getBeatDistance();
+    if (!pSource->isPlaying()) {
+        // If the params source is not playing, but other syncables are, then we are a stopped
+        // explicit Master and we should not initialize the beat distance.  Take it from the
+        // internal clock instead, because that will be up to date with the playing deck(s).
+        bool playingSyncables = false;
+        for (Syncable* pSyncable : qAsConst(m_syncables)) {
+            if (pSyncable == pSource) {
+                continue;
+            }
+            if (!pSyncable->isSynchronized()) {
+                continue;
+            }
+            if (pSyncable->isPlaying()) {
+                playingSyncables = true;
+                break;
+            }
+        }
+        if (playingSyncables) {
+            beatDistance = m_pInternalClock->getBeatDistance();
+        }
+    }
     const double baseBpm = pSource->getBaseBpm();
     double bpm = pSource->getBpm();
     if (bpm <= 0) {
         bpm = baseBpm;
     }
-    // qDebug() << "BaseSyncableListener::setMasterParams, source is"
-    //          << pSource->getGroup() << beatDistance << baseBpm << bpm;
+    if (kLogger.traceEnabled()) {
+        kLogger.trace() << "BaseSyncableListener::setMasterParams, source is"
+                        << pSource->getGroup() << beatDistance << baseBpm << bpm;
+    }
     if (pSource != m_pInternalClock) {
         m_pInternalClock->setMasterParams(beatDistance, baseBpm, bpm);
     }
     foreach (Syncable* pSyncable, m_syncables) {
-        if (pSyncable == pSource || !pSyncable->isSynchronized()) {
+        if (!pSyncable->isSynchronized()) {
             continue;
         }
         pSyncable->setMasterParams(beatDistance, baseBpm, bpm);
     }
 }
 
-bool EngineSync::noPlayingFollowers() const {
+Syncable* EngineSync::getUniquePlayingSyncedDeck() const {
+    Syncable* onlyPlaying = nullptr;
     for (Syncable* pSyncable : m_syncables) {
         if (!pSyncable->isSynchronized()) {
             continue;
         }
 
-        if (pSyncable->isPlaying() && pSyncable->isAudible() &&
-                isFollower(pSyncable->getSyncMode())) {
-            return false;
+        if (pSyncable->isPlaying()) {
+            if (!onlyPlaying) {
+                onlyPlaying = pSyncable;
+            } else {
+                return nullptr;
+            }
         }
     }
-    return true;
+    return onlyPlaying;
 }

src/engine/sync/enginesync.h

@@ -115,8 +115,9 @@ class EngineSync : public SyncableListener {
 
     void setMasterParams(Syncable* pSource);
 
-    /// Check if there are no playing followers left.
-    bool noPlayingFollowers() const;
+    /// Iff there is a single playing syncable in sync mode, return it.
+    /// This is used to initialize master params.
+    Syncable* getUniquePlayingSyncedDeck() const;
 
     /// Only for testing. Do not use.
     Syncable* getSyncableForGroup(const QString& group);

src/engine/sync/internalclock.cpp

@@ -60,7 +60,7 @@ void InternalClock::setSyncMode(SyncMode mode) {
     m_pSyncMasterEnabled->setAndConfirm(SyncModeToMasterLight(mode));
 }
 
-void InternalClock::notifyOnlyPlayingSyncable() {
+void InternalClock::notifyUniquePlaying() {
     // No action necessary.
 }
 
@@ -140,6 +140,9 @@ void InternalClock::setInstantaneousBpm(double bpm) {
     Q_UNUSED(bpm);
 }
 
+void InternalClock::notifyMasterParamSource() {
+}
+
 void InternalClock::setMasterParams(double beatDistance, double baseBpm, double bpm) {
     if (kLogger.traceEnabled()) {
         kLogger.trace() << "InternalClock::setMasterParams" << beatDistance << baseBpm << bpm;

src/engine/sync/internalclock.h

@@ -32,7 +32,7 @@ class InternalClock : public QObject, public Clock, public Syncable {
     }
 
     void setSyncMode(SyncMode mode) override;
-    void notifyOnlyPlayingSyncable() override;
+    void notifyUniquePlaying() override;
     void requestSync() override;
     SyncMode getSyncMode() const override {
         return m_mode;
@@ -52,6 +52,7 @@ class InternalClock : public QObject, public Clock, public Syncable {
 
     double getBaseBpm() const override;
     void setMasterBpm(double bpm) override;
+    void notifyMasterParamSource() override;
     double getBpm() const override;
     void setInstantaneousBpm(double bpm) override;
     void setMasterParams(double beatDistance, double baseBpm, double bpm) override;