Merge pull request #6608 from peppy/decoupled-clock-not-starting-source

Fix `DecouplingFramedClock` not starting source in edge case scenario

Author: peppy

osu.Framework.Tests/Clocks/DecouplingFramedClockTest.cs

@@ -57,6 +57,36 @@ public void TestStartFromSource(bool allowDecoupling)
             Assert.That(decouplingClock.IsRunning, Is.True);
         }
 
+        [Test]
+        public void TestSeekFromDecouplingWithoutProcessFrame()
+        {
+            decouplingClock.AllowDecoupling = true;
+
+            Assert.That(source.CurrentTime, Is.EqualTo(0));
+            Assert.That(decouplingClock.CurrentTime, Is.EqualTo(0));
+
+            decouplingClock.Start();
+
+            decouplingClock.Seek(1000);
+            decouplingClock.ProcessFrame();
+            Assert.That(source.IsRunning, Is.True);
+
+            decouplingClock.Seek(-1000);
+            // Intentionally no process frame.
+            Assert.That(source.IsRunning, Is.False);
+
+            decouplingClock.Seek(-1);
+
+            // intentionally make sure that reference time has increased to push time into positive before a process frame.
+            Thread.Sleep(500);
+            decouplingClock.ProcessFrame();
+
+            while (decouplingClock.CurrentTime < 0)
+                decouplingClock.ProcessFrame();
+
+            Assert.That(source.IsRunning, Is.True);
+        }
+
         [TestCase(true)]
         [TestCase(false)]
         public void TestSeekFromDecoupling(bool allowDecoupling)

osu.Framework/Timing/DecouplingFramedClock.cs

@@ -75,6 +75,12 @@ public sealed class DecouplingFramedClock : ISourceChangeableClock, IAdjustableC
 
         private IAdjustableClock adjustableSourceClock;
 
+        /// <summary>
+        /// Denotes a state where a negative seek stopped the source clock and entered decoupled mode, meaning that
+        /// after crossing into positive time again we should attempt to start and use the source clock.
+        /// </summary>
+        private bool pendingSourceRestartAfterNegativeSeek;
+
         public DecouplingFramedClock(IClock? source = null)
         {
             ChangeSource(source);
@@ -118,12 +124,12 @@ public void ProcessFrame()
 
                 currentTime += elapsedReferenceTime;
 
-                // When crossing the zero time boundary forwards, we should start and use the source clock.
-                // Note that this implicitly assumes the source starts at zero,
-                // and additionally the right-side boundary is not handled as we don't know where the source's max time is.
-                // This could be potentially handled if need be, if we had a notion of what the source's max allowable time is.
-                if (lastTime < 0 && currentTime >= 0)
+                // When crossing into positive time, we should attempt to start and use the source clock.
+                // Note that this carries the common assumption that the source clock *should* be able to run from zero.
+                if (pendingSourceRestartAfterNegativeSeek && currentTime >= 0)
                 {
+                    pendingSourceRestartAfterNegativeSeek = false;
+
                     // We still need to check the seek was successful, else we might have already exceeded valid length of the source.
                     lastSeekFailed = !adjustableSourceClock.Seek(currentTime);
                     if (!lastSeekFailed)
@@ -166,6 +172,7 @@ public void ChangeSource(IClock? source)
         public void Reset()
         {
             adjustableSourceClock.Reset();
+            pendingSourceRestartAfterNegativeSeek = false;
             shouldBeRunning = false;
             lastSeekFailed = false;
             currentTime = 0;
@@ -212,6 +219,7 @@ public bool Seek(double position)
 
                 // Ensure the underlying clock is stopped as we enter decoupled mode.
                 adjustableSourceClock.Stop();
+                pendingSourceRestartAfterNegativeSeek = position < 0;
             }
 
             currentTime = position;