Fix seeking and pausing support (with tests)

osu.Framework.Tests/Visual/Sprites/TestSceneAnimation.cs

···
 {
     public class TestSceneAnimation : FrameworkTestScene
     {
-        private readonly Container animationContainer;
-        private readonly SpriteText timeText;
+        private SpriteText timeText;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
···
 
         private TestAnimation animation;
 
-        public TestSceneAnimation()
-        {
-            Children = new Drawable[]
-            {
-                animationContainer = new Container { RelativeSizeAxes = Axes.Both },
-                timeText = new SpriteText { Text = "Animation is loading..." }
-            };
-        }
-
         [SetUpSteps]
         public void SetUpSteps()
         {
             AddStep("load video", () =>
             {
-                animationContainer.Child = animation = new TestAnimation
+                Children = new Drawable[]
                 {
-                    Repeat = false,
-                    Clock = new FramedClock(clock = new ManualClock()),
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Clock = new FramedClock(clock = new ManualClock()),
+                        Child = animation = new TestAnimation
+                        {
+                            Repeat = false,
+                        }
+                    },
+                    timeText = new SpriteText { Text = "Animation is loading..." }
                 };
             });
 
···
         }
 
         [Test]
+        public void TestFrameSeeking()
+        {
+            AddAssert("frame count is correct", () => animation.FrameCount == TestAnimation.LOADABLE_FRAMES);
+            AddUntilStep("wait for frames to pass", () => animation.CurrentFrameIndex > 10);
+            AddStep("stop animation", () => animation.Stop());
+            AddAssert("is stopped", () => !animation.IsPlaying);
+
+            AddStep("goto frame 60", () => animation.GotoFrame(60));
+            AddAssert("is at frame 60", () => animation.CurrentFrameIndex == 60);
+
+            AddStep("goto frame 30", () => animation.GotoFrame(30));
+            AddAssert("is at frame 30", () => animation.CurrentFrameIndex == 30);
+
+            AddStep("goto frame 60", () => animation.GotoFrame(60));
+            AddAssert("is at frame 60", () => animation.CurrentFrameIndex == 60);
+
+            AddStep("start animation", () => animation.Play());
+            AddUntilStep("continues to frame 70", () => animation.CurrentFrameIndex == 70);
+        }
+
+        [Test]
         public void TestJumpForward()
         {
             AddStep("Jump ahead by 10 seconds", () => clock.CurrentTime += 10000);
···
 
         private class TestAnimation : TextureAnimation
         {
+            public const int LOADABLE_FRAMES = 72;
+
             [Resolved]
             private FontStore fontStore { get; set; }
 
             public int FramesProcessed;
 
             public TestAnimation()
-                : base(false)
             {
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
···
             [BackgroundDependencyLoader]
             private void load()
             {
-                for (int i = 0; i <= 72; i++)
+                for (int i = 0; i < LOADABLE_FRAMES; i++)
                 {
                     AddFrame(new Texture(fontStore.Get(null, (char)('0' + i)).Texture.TextureGL)
                     {

osu.Framework/Graphics/Animations/Animation.cs

···
             if (!startAtCurrentTime)
                 throw new InvalidOperationException($"A {nameof(Animation<T>)} with {startAtCurrentTime} = false cannot seek as it is dependent on an external clock.");
 
-            offsetClock.Offset = offsetClock.CurrentTime + frameData[frameIndex].DisplayTime;
+            offsetClock.Offset = frameData[frameIndex].DisplayStartTime - offsetClock.Source.CurrentTime;
             currentFrameCache.Invalidate();
         }
 
···
         {
             var lastFrame = frameData.LastOrDefault();
 
-            frame.DisplayTime = lastFrame.DisplayTime + lastFrame.Duration;
+            frame.DisplayStartTime = lastFrame.DisplayEndTime;
             Duration += frame.Duration;
 
             frameData.Add(frame);
···
         {
             base.Update();
 
-            if (!IsPlaying || frameData.Count <= 0) return;
+            if (!IsPlaying)
+                offsetClock.Offset -= Time.Elapsed;
 
-            while (CurrentFrameIndex < frameData.Count && PlaybackPosition > frameData[CurrentFrameIndex].DisplayTime + frameData[CurrentFrameIndex].Duration)
-            {
-                CurrentFrameIndex++;
-                currentFrameCache.Invalidate();
-            }
+            if (frameData.Count == 0) return;
 
-            while (CurrentFrameIndex > 0 && PlaybackPosition < frameData[CurrentFrameIndex].DisplayTime)
+            switch (PlaybackPosition.CompareTo(frameData[CurrentFrameIndex].DisplayStartTime))
             {
-                CurrentFrameIndex--;
-                currentFrameCache.Invalidate();
+                case -1:
+                    while (CurrentFrameIndex > 0 && PlaybackPosition < frameData[CurrentFrameIndex].DisplayStartTime)
+                    {
+                        CurrentFrameIndex--;
+                        currentFrameCache.Invalidate();
+                    }
+
+                    break;
+
+                case 1:
+                    while (CurrentFrameIndex < frameData.Count - 1 && PlaybackPosition >= frameData[CurrentFrameIndex].DisplayEndTime)
+                    {
+                        CurrentFrameIndex++;
+                        currentFrameCache.Invalidate();
+                    }
+
+                    break;
             }
 
             if (!currentFrameCache.IsValid)

osu.Framework/Graphics/Animations/FrameData.cs

···
         /// <summary>
         /// The time at which this frame is displayed in the containing animation.
         /// </summary>
-        internal double DisplayTime { get; set; }
+        internal double DisplayStartTime { get; set; }
+
+        /// <summary>
+        /// The time at which this frame is no longer displayed.
+        /// </summary>
+        internal double DisplayEndTime => DisplayStartTime + Duration;
     }
 }