Merge branch 'logging-track' into release

osu.Game.Tests/Skins/TestSceneBeatmapSkinResources.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Tests.Skins
             AddAssert("sample is non-null", () => beatmap.Skin.GetSample(new SampleInfo(@"sample")) != null);
             AddAssert("track is non-null", () =>
             {
-                using (var track = beatmap.LoadTrack())
+                using (var track = beatmap.LoadTrack().GetUnderlyingTrack())
                     return track is not TrackVirtual;
             });
         }

osu.Game.Tests/Visual/Audio/TestSceneAudioFilter.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Game.Audio.Effects;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 
@@ -38,7 +39,7 @@ namespace osu.Game.Tests.Visual.Audio
         private void load(AudioManager audio)
         {
             beatmap = new WaveformTestBeatmap(audio);
-            track = beatmap.LoadTrack();
+            track = beatmap.LoadTrack().GetUnderlyingTrack();
 
             Add(new FillFlowContainer
             {

osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs

@@ -99,7 +99,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddUntilStep("wait for timeline load", () => Editor.ChildrenOfType<Timeline>().FirstOrDefault()?.IsLoaded == true);
 
             AddStep("enter setup mode", () => InputManager.Key(Key.F4));
-            AddAssert("track is virtual", () => Beatmap.Value.Track is TrackVirtual);
+            AddAssert("track is virtual", () => Beatmap.Value.Track.GetUnderlyingTrack() is TrackVirtual);
             AddAssert("switch track to real track", () =>
             {
                 var setup = Editor.ChildrenOfType<SetupScreen>().First();

osu.Game.Tests/Visual/Editing/TimelineTestScene.cs

@@ -121,7 +121,7 @@ namespace osu.Game.Tests.Visual.Editing
             {
                 base.Update();
 
-                if (beatmap.Value.Track.IsLoaded)
+                if (beatmap.Value.Track.IsLoaded())
                     marker.X = (float)(editorClock.CurrentTime / beatmap.Value.Track.Length);
             }
         }

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -72,7 +72,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// Retrieves the <see cref="Track"/> which this <see cref="IWorkingBeatmap"/> has loaded.
         /// </summary>
-        Track Track { get; }
+        ITrack Track { get; }
 
         /// <summary>
         /// Constructs a playable <see cref="IBeatmap"/> from <see cref="Beatmap"/> using the applicable converters for a specific <see cref="RulesetInfo"/>.
@@ -118,7 +118,7 @@ namespace osu.Game.Beatmaps
         /// outside of the game context.
         /// </remarks>
         /// <returns>A fresh track instance, which will also be available via <see cref="Track"/>.</returns>
-        Track LoadTrack();
+        ITrack LoadTrack();
 
         /// <summary>
         /// Returns the stream of the file from the given storage path.

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -13,7 +13,9 @@ using System.Threading.Tasks;
 using JetBrains.Annotations;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Logging;
 using osu.Game.Rulesets;
@@ -45,7 +47,7 @@ namespace osu.Game.Beatmaps
         private readonly Lazy<Storyboard> storyboard;
         private readonly Lazy<ISkin> skin;
 
-        private Track track; // track is not Lazy as we allow transferring and loading multiple times.
+        private ITrack track; // track is not Lazy as we allow transferring and loading multiple times.
         private Waveform waveform; // waveform is also not Lazy as the track may change.
 
         protected WorkingBeatmap(BeatmapInfo beatmapInfo, AudioManager audioManager)
@@ -103,9 +105,9 @@ namespace osu.Game.Beatmaps
 
         public virtual bool TrackLoaded => track != null;
 
-        public Track LoadTrack()
+        public ITrack LoadTrack()
         {
-            track = GetBeatmapTrack() ?? GetVirtualTrack(1000);
+            track = new LoggingTrack(GetBeatmapTrack() ?? GetVirtualTrack(1000));
 
             // the track may have changed, recycle the current waveform.
             waveform?.Dispose();
@@ -121,7 +123,7 @@ namespace osu.Game.Beatmaps
 
             if (Track.RestartPoint == -1)
             {
-                if (!Track.IsLoaded)
+                if (!Track.IsLoaded())
                 {
                     // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
                     Track.Seek(Track.CurrentTime);
@@ -153,7 +155,7 @@ namespace osu.Game.Beatmaps
         /// This generally happens via MusicController when changing the global beatmap.
         /// </summary>
         [NotNull]
-        public Track Track
+        public ITrack Track
         {
             get
             {
@@ -353,4 +355,186 @@ namespace osu.Game.Beatmaps
             }
         }
     }
+
+    /// <summary>
+    /// Temporary helper extension methods to aid in using <see cref="LoggingTrack"/> with minimal code damage.
+    /// </summary>
+    internal static class TrackExtensions
+    {
+        public static Track GetUnderlyingTrack(this ITrack track)
+        {
+            if (track is Track t)
+                return t;
+
+            if (track is LoggingTrack lt)
+                return lt.UnderlyingTrack;
+
+            return null;
+        }
+
+        public static bool IsLoaded(this ITrack track)
+        {
+            if (track is Track t)
+                return t.IsLoaded;
+
+            if (track is LoggingTrack lt)
+                return lt.UnderlyingTrack.IsLoaded;
+
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Temporary redirect class for logging purposes.
+    /// </summary>
+    internal class LoggingTrack : ITrack, IDisposable
+    {
+        public readonly Track UnderlyingTrack;
+
+        public LoggingTrack(Track underlyingTrack)
+        {
+            UnderlyingTrack = underlyingTrack;
+        }
+
+        public double CurrentTime => UnderlyingTrack.CurrentTime;
+
+        public void Reset()
+        {
+            UnderlyingTrack.Reset();
+        }
+
+        public void Start()
+        {
+            UnderlyingTrack.Start();
+        }
+
+        public void Stop()
+        {
+            UnderlyingTrack.Stop();
+        }
+
+        public bool Seek(double position)
+        {
+            Logger.Log($"{nameof(Seek)} on {UnderlyingTrack.GetType().ReadableName()} from {UnderlyingTrack.CurrentTime:N2} to {position:N2}");
+            return UnderlyingTrack.Seek(position);
+        }
+
+        public void ResetSpeedAdjustments()
+        {
+            UnderlyingTrack.ResetSpeedAdjustments();
+        }
+
+        public double Rate
+        {
+            get => UnderlyingTrack.Rate;
+            set => UnderlyingTrack.Rate = value;
+        }
+
+        public bool IsRunning => UnderlyingTrack.IsRunning;
+
+        public ChannelAmplitudes CurrentAmplitudes => UnderlyingTrack.CurrentAmplitudes;
+
+        public IBindable<double> AggregateVolume => UnderlyingTrack.AggregateVolume;
+
+        IBindable<double> IAggregateAudioAdjustment.AggregateVolume => UnderlyingTrack.AggregateVolume;
+
+        public IBindable<double> AggregateBalance => UnderlyingTrack.AggregateBalance;
+
+        public IBindable<double> AggregateFrequency => UnderlyingTrack.AggregateFrequency;
+
+        public IBindable<double> AggregateTempo => UnderlyingTrack.AggregateTempo;
+
+        public void BindAdjustments(IAggregateAudioAdjustment component)
+        {
+            UnderlyingTrack.BindAdjustments(component);
+        }
+
+        public void UnbindAdjustments(IAggregateAudioAdjustment component)
+        {
+            UnderlyingTrack.UnbindAdjustments(component);
+        }
+
+        void IAdjustableAudioComponent.AddAdjustment(AdjustableProperty type, IBindable<double> adjustBindable)
+        {
+            UnderlyingTrack.AddAdjustment(type, adjustBindable);
+        }
+
+        void IAdjustableAudioComponent.RemoveAdjustment(AdjustableProperty type, IBindable<double> adjustBindable)
+        {
+            UnderlyingTrack.RemoveAdjustment(type, adjustBindable);
+        }
+
+        public void AddAdjustment(AdjustableProperty type, IBindable<double> adjustBindable)
+        {
+            UnderlyingTrack.AddAdjustment(type, adjustBindable);
+        }
+
+        public void RemoveAdjustment(AdjustableProperty type, IBindable<double> adjustBindable)
+        {
+            UnderlyingTrack.RemoveAdjustment(type, adjustBindable);
+        }
+
+        public void RemoveAllAdjustments(AdjustableProperty type)
+        {
+            UnderlyingTrack.RemoveAllAdjustments(type);
+        }
+
+        public BindableNumber<double> Volume => UnderlyingTrack.Volume;
+
+        public BindableNumber<double> Balance => UnderlyingTrack.Balance;
+
+        public BindableNumber<double> Frequency => UnderlyingTrack.Frequency;
+
+        public BindableNumber<double> Tempo => UnderlyingTrack.Tempo;
+
+        public void Restart()
+        {
+            UnderlyingTrack.Restart();
+        }
+
+        public bool Looping
+        {
+            get => UnderlyingTrack.Looping;
+            set => UnderlyingTrack.Looping = value;
+        }
+
+        public bool IsDummyDevice => UnderlyingTrack.IsDummyDevice;
+
+        public double RestartPoint
+        {
+            get => UnderlyingTrack.RestartPoint;
+            set => UnderlyingTrack.RestartPoint = value;
+        }
+
+        public double Length
+        {
+            get => UnderlyingTrack.Length;
+            set => UnderlyingTrack.Length = value;
+        }
+
+        public int? Bitrate => UnderlyingTrack.Bitrate;
+
+        public bool IsReversed => UnderlyingTrack.IsReversed;
+
+        public bool HasCompleted => UnderlyingTrack.HasCompleted;
+
+        public bool IsLoaded => UnderlyingTrack.IsLoaded;
+
+        public event Action Completed
+        {
+            add => UnderlyingTrack.Completed += value;
+            remove => UnderlyingTrack.Completed -= value;
+        }
+
+        public event Action Failed
+        {
+            add => UnderlyingTrack.Failed += value;
+            remove => UnderlyingTrack.Failed -= value;
+        }
+
+        public void Dispose()
+        {
+            UnderlyingTrack.Dispose();
+        }
+    }
 }

osu.Game/Overlays/MusicController.cs

@@ -361,7 +361,7 @@ namespace osu.Game.Overlays
         {
             // Important to keep this in its own method to avoid inadvertently capturing unnecessary variables in the callback.
             // Can lead to leaks.
-            var queuedTrack = new DrawableTrack(current.LoadTrack());
+            var queuedTrack = new DrawableTrack(current.LoadTrack().GetUnderlyingTrack());
             queuedTrack.Completed += onTrackCompleted;
             return queuedTrack;
         }

osu.Game/Screens/Edit/Components/BottomBarContainer.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Screens.Edit.Components
 
         protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 
-        protected readonly IBindable<Track> Track = new Bindable<Track>();
+        protected readonly IBindable<ITrack> Track = new Bindable<ITrack>();
 
         protected readonly Drawable Background;
         private readonly Container content;

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/TimelinePart.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
         [Resolved]
         protected EditorBeatmap EditorBeatmap { get; private set; } = null!;
 
-        protected readonly IBindable<Track> Track = new Bindable<Track>();
+        protected readonly IBindable<ITrack> Track = new Bindable<ITrack>();
 
         private readonly Container<T> content;
 
@@ -56,11 +56,13 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
         private void updateRelativeChildSize()
         {
             // If the track is not loaded, assign a default sane length otherwise relative positioning becomes meaningless.
-            double trackLength = beatmap.Value.Track.IsLoaded ? beatmap.Value.Track.Length : 60000;
+            var track = beatmap.Value.Track.GetUnderlyingTrack();
+
+            double trackLength = track.IsLoaded ? track.Length : 60000;
             content.RelativeChildSize = new Vector2((float)Math.Max(1, trackLength), 1);
 
             // The track may not be loaded completely (only has a length once it is).
-            if (!beatmap.Value.Track.IsLoaded)
+            if (!track.IsLoaded)
                 Schedule(updateRelativeChildSize);
         }
 

osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs

@@ -91,7 +91,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private double trackLengthForZoom;
 
-        private readonly IBindable<Track> track = new Bindable<Track>();
+        private readonly IBindable<ITrack> track = new Bindable<ITrack>();
 
         [BackgroundDependencyLoader]
         private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, OsuConfigManager config)

osu.Game/Screens/Edit/EditorClock.cs

@@ -23,11 +23,11 @@ namespace osu.Game.Screens.Edit
     /// </summary>
     public partial class EditorClock : CompositeComponent, IFrameBasedClock, IAdjustableClock, ISourceChangeableClock
     {
-        public IBindable<Track> Track => track;
+        public IBindable<ITrack> Track => track;
 
-        private readonly Bindable<Track> track = new Bindable<Track>();
+        private readonly Bindable<ITrack> track = new Bindable<ITrack>();
 
-        public double TrackLength => track.Value?.IsLoaded == true ? track.Value.Length : 60000;
+        public double TrackLength => track.Value?.IsLoaded() == true ? track.Value.Length : 60000;
 
         public ControlPointInfo ControlPointInfo => Beatmap.ControlPointInfo;
 
@@ -231,7 +231,7 @@ namespace osu.Game.Screens.Edit
 
         public void ChangeSource(IClock source)
         {
-            track.Value = source as Track;
+            track.Value = source as ITrack;
             underlyingClock.ChangeSource(source);
         }
 

osu.Game/Screens/Edit/Timing/WaveformComparisonDisplay.cs

@@ -192,7 +192,7 @@ namespace osu.Game.Screens.Edit.Timing
         private void regenerateDisplay(bool animated)
         {
             // Before a track is loaded, it won't have a valid length, which will break things.
-            if (!beatmap.Value.Track.IsLoaded)
+            if (!beatmap.Value.Track.IsLoaded())
             {
                 Scheduler.AddOnce(regenerateDisplay, animated);
                 return;
@@ -305,7 +305,7 @@ namespace osu.Game.Screens.Edit.Timing
             [Resolved]
             private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
 
-            private readonly IBindable<Track> track = new Bindable<Track>();
+            private readonly IBindable<ITrack> track = new Bindable<ITrack>();
 
             public WaveformRow(bool isMainRow)
             {

osu.Game/Screens/Play/FailAnimationContainer.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Screens.Play
 
         private Box redFlashLayer = null!;
 
-        private Track track = null!;
+        private ITrack track = null!;
 
         private AudioFilter failLowPassFilter = null!;
         private AudioFilter failHighPassFilter = null!;

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Screens.Play
 
         private readonly WorkingBeatmap beatmap;
 
-        private Track track;
+        private ITrack track;
 
         private readonly double skipTargetTime;