new loop and beatjump controls

build/depends.py

@@ -826,6 +826,7 @@ def sources(self, build):
                    "widget/wlabel.cpp",
                    "widget/wtracktext.cpp",
                    "widget/wnumber.cpp",
+                   "widget/wbeatspinbox.cpp",
                    "widget/wnumberdb.cpp",
                    "widget/wnumberpos.cpp",
                    "widget/wnumberrate.cpp",

src/engine/bpmcontrol.cpp

@@ -400,7 +400,7 @@ double BpmControl::calcSyncedRate(double userTweak) {
 
     // Now that we have our beat distance we can also check how large the
     // current loop is.  If we are in a <1 beat loop, don't worry about offset.
-    const bool loop_enabled = m_pLoopEnabled->get() > 0.0;
+    const bool loop_enabled = m_pLoopEnabled->toBool();
     const double loop_size = (m_pLoopEndPosition->get() -
                               m_pLoopStartPosition->get()) /
                               dBeatLength;
@@ -567,14 +567,14 @@ bool BpmControl::getBeatContextNoLookup(
     return true;
 }
 
-double BpmControl::getPhaseOffset(double dThisPosition) {
+double BpmControl::getNearestPositionInPhase(double dThisPosition, bool respectLoops, bool playing) {
     // Without a beatgrid, we don't know the phase offset.
     if (!m_pBeats) {
-        return 0;
+        return dThisPosition;
     }
     // Master buffer is always in sync!
     if (getSyncMode() == SYNC_MASTER) {
-        return 0;
+        return dThisPosition;
     }
 
     // Get the current position of this deck.
@@ -588,13 +588,13 @@ double BpmControl::getPhaseOffset(double dThisPosition) {
         if (!getBeatContext(m_pBeats, dThisPosition,
                             &dThisPrevBeat, &dThisNextBeat,
                             &dThisBeatLength, NULL)) {
-            return 0;
+            return dThisPosition;
         }
     } else {
         if (!getBeatContextNoLookup(dThisPosition,
                                     dThisPrevBeat, dThisNextBeat,
                                     &dThisBeatLength, NULL)) {
-            return 0;
+            return dThisPosition;
         }
     }
 
@@ -606,15 +606,23 @@ double BpmControl::getPhaseOffset(double dThisPosition) {
         // If not, we have to figure it out
         EngineBuffer* pOtherEngineBuffer = pickSyncTarget();
         if (pOtherEngineBuffer == NULL) {
-            return 0;
+            return dThisPosition;
+        }
+
+        if (playing) {
+            // "this" track is playing, or just starting
+            // only match phase if the sync target is playing as well
+            if (pOtherEngineBuffer->getSpeed() == 0.0) {
+                return dThisPosition;
+            }
         }
 
         TrackPointer otherTrack = pOtherEngineBuffer->getLoadedTrack();
         BeatsPointer otherBeats = otherTrack ? otherTrack->getBeats() : BeatsPointer();
 
         // If either track does not have beats, then we can't adjust the phase.
         if (!otherBeats) {
-            return 0;
+            return dThisPosition;
         }
 
         double dOtherLength = ControlObject::getControl(
@@ -624,7 +632,7 @@ double BpmControl::getPhaseOffset(double dThisPosition) {
 
         if (!BpmControl::getBeatContext(otherBeats, dOtherPosition,
                                         NULL, NULL, NULL, &dOtherBeatFraction)) {
-            return 0.0;
+            return dThisPosition;
         }
     }
 
@@ -658,51 +666,55 @@ double BpmControl::getPhaseOffset(double dThisPosition) {
         dNewPlaypos += dThisPrevBeat;
     }
 
-    // We might be seeking outside the loop.
-    const bool loop_enabled = m_pLoopEnabled->get() > 0.0;
-    const double loop_start_position = m_pLoopStartPosition->get();
-    const double loop_end_position = m_pLoopEndPosition->get();
-
-    // Cases for sanity:
-    //
-    // CASE 1
-    // Two identical 1-beat loops, out of phase by X samples.
-    // Other deck is at its loop start.
-    // This deck is half way through. We want to jump forward X samples to the loop end point.
-    //
-    // Two identical 1-beat loop, out of phase by X samples.
-    // Other deck is
-
-    // If sync target is 50% through the beat,
-    // If we are at the loop end point and hit sync, jump forward X samples.
-
-
-    // TODO(rryan): Revise this with something that keeps a broader number of
-    // cases in sync. This at least prevents breaking out of the loop.
-    if (loop_enabled) {
-        const double loop_length = loop_end_position - loop_start_position;
-        if (loop_length <= 0.0) {
-            return false;
-        }
-
-        // TODO(rryan): If loop_length is not a multiple of dThisBeatLength should
-        // we bail and not sync phase?
-
-        // Syncing to after the loop end.
-        double end_delta = dNewPlaypos - loop_end_position;
-        if (end_delta > 0) {
-            int i = end_delta / loop_length;
-            dNewPlaypos = loop_start_position + end_delta - i * loop_length;
-        }
-
-        // Syncing to before the loop beginning.
-        double start_delta = loop_start_position - dNewPlaypos;
-        if (start_delta > 0) {
-            int i = start_delta / loop_length;
-            dNewPlaypos = loop_end_position - start_delta + i * loop_length;
+    if (respectLoops) {
+        // We might be seeking outside the loop.
+        const bool loop_enabled = m_pLoopEnabled->toBool();
+        const double loop_start_position = m_pLoopStartPosition->get();
+        const double loop_end_position = m_pLoopEndPosition->get();
+
+        // Cases for sanity:
+        //
+        // CASE 1
+        // Two identical 1-beat loops, out of phase by X samples.
+        // Other deck is at its loop start.
+        // This deck is half way through. We want to jump forward X samples to the loop end point.
+        //
+        // Two identical 1-beat loop, out of phase by X samples.
+        // Other deck is
+
+        // If sync target is 50% through the beat,
+        // If we are at the loop end point and hit sync, jump forward X samples.
+
+
+        // TODO(rryan): Revise this with something that keeps a broader number of
+        // cases in sync. This at least prevents breaking out of the loop.
+        if (loop_enabled &&
+                dThisPosition <= loop_end_position) {
+            const double loop_length = loop_end_position - loop_start_position;
+            const double end_delta = dNewPlaypos - loop_end_position;
+
+            // Syncing to after the loop end.
+            if (end_delta > 0 && loop_length > 0.0) {
+                int i = end_delta / loop_length;
+                dNewPlaypos = loop_start_position + end_delta - i * loop_length;
+
+                // Move new position after loop jump into phase as well.
+                // This is a recursive call, called only twice because of
+                // respectLoops = false
+                dNewPlaypos = getNearestPositionInPhase(dNewPlaypos, false, playing);
+            }
+
+            // Note: Syncing to before the loop beginning is allowed, because
+            // loops are catching
         }
     }
 
+    return dNewPlaypos;
+}
+
+double BpmControl::getPhaseOffset(double dThisPosition) {
+    // This does not respect looping
+    double dNewPlaypos = getNearestPositionInPhase(dThisPosition, false, false);
     return dNewPlaypos - dThisPosition;
 }
 

src/engine/bpmcontrol.h

@@ -33,7 +33,8 @@ class BpmControl : public EngineControl {
     // out of sync.
     double calcSyncedRate(double userTweak);
     // Get the phase offset from the specified position.
-    double getPhaseOffset(double reference_position);
+    double getNearestPositionInPhase(double dThisPosition, bool respectLoops, bool playing);
+    double getPhaseOffset(double dThisPosition);
     double getBeatDistance(double dThisPosition) const;
     double getPreviousSample() const { return m_dPreviousSample; }
 

src/engine/enginebuffer.cpp

@@ -1165,7 +1165,7 @@ void EngineBuffer::processSeek(bool paused) {
     }
 
     if ((seekType & SEEK_PHASE) && !paused && m_pQuantize->toBool()) {
-        position += m_pBpmControl->getPhaseOffset(position);
+        position = m_pBpmControl->getNearestPositionInPhase(position, true, true);
     }
 
     double newPlayFrame = position / kSamplesPerFrame;

src/engine/enginebuffer.h

@@ -231,9 +231,12 @@ class EngineBuffer : public EngineObject {
     UserSettingsPointer m_pConfig;
 
     LoopingControl* m_pLoopingControl;
-    FRIEND_TEST(LoopingControlTest, LoopHalveButton_HalvesLoop);
+    FRIEND_TEST(LoopingControlTest, LoopScale_HalvesLoop);
     FRIEND_TEST(LoopingControlTest, LoopMoveTest);
     FRIEND_TEST(LoopingControlTest, LoopResizeSeek);
+    FRIEND_TEST(LoopingControlTest, ReloopToggleButton_DoesNotJumpAhead);
+    FRIEND_TEST(LoopingControlTest, ReloopAndStopButton);
+    FRIEND_TEST(LoopingControlTest, Beatjump_JumpsByBeats);
     FRIEND_TEST(SyncControlTest, TestDetermineBpmMultiplier);
     FRIEND_TEST(EngineSyncTest, HalfDoubleBpmTest);
     FRIEND_TEST(EngineSyncTest, HalfDoubleThenPlay);