Initial rework of sample + samplechannel

osu.Framework.Tests/Audio/SampleBassTest.cs

···
     public class SampleBassTest
     {
         private DllResourceStore resources;
-
-        private SampleBass sample;
-
-        private SampleChannelBass channel;
+        private Sample sample;
+        private SampleChannel channel;
 
         [SetUp]
         public void Setup()
···
             Bass.Init(0);
 
             resources = new DllResourceStore(typeof(TrackBassTest).Assembly);
-
             sample = new SampleBass(resources.Get("Resources.Tracks.sample-track.mp3"));
 
-            channel = new SampleChannelBass(sample, channel => { });
             updateSample();
         }
 
···
         [Test]
         public void TestStart()
         {
-            channel.Play();
+            channel = sample.Play();
             updateSample();
 
             Thread.Sleep(50);
···
         [Test]
         public void TestStop()
         {
-            channel.Play();
+            channel = sample.Play();
             updateSample();
 
             channel.Stop();
···
         [Test]
         public void TestStopBeforeLoadFinished()
         {
-            channel.Play();
+            channel = sample.Play();
             channel.Stop();
 
             updateSample();
···
         private void updateSample() => runOnAudioThread(() =>
         {
             sample.Update();
-            channel.Update();
+            channel?.Update();
         });
 
         /// <summary>

osu.Framework.Tests/Audio/SampleChannelVirtualTest.cs

···
             Assert.IsFalse(channel.Played);
             Assert.IsFalse(channel.HasCompleted);
 
-            channel.Play();
             updateChannel();
 
             Thread.Sleep(50);

osu.Framework.Tests/Visual/Audio/TestSceneSampleAmplitudes.cs

···
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Containers;
···
 {
     public class TestSceneSampleAmplitudes : FrameworkTestScene
     {
-        private DrawableSample sample;
-
         private Box leftChannel;
         private Box rightChannel;
 
-        private SampleChannelBass bassSample;
+        private DrawableSample sample;
+        private SampleChannel channel;
 
         private Container amplitudeBoxes;
 
         [BackgroundDependencyLoader]
         private void load(ISampleStore samples)
         {
-            bassSample = (SampleChannelBass)samples.Get("long.mp3");
-
-            var length = bassSample.CurrentAmplitudes.FrequencyAmplitudes.Length;
-
             Children = new Drawable[]
             {
-                sample = new DrawableSample(bassSample),
+                sample = new DrawableSample(samples.Get("long.mp3")),
                 new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
···
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 ChildrenEnumerable =
-                                    Enumerable.Range(0, length)
+                                    Enumerable.Range(0, ChannelAmplitudes.AMPLITUDES_SIZE)
                                               .Select(i => new Box
                                               {
                                                   RelativeSizeAxes = Axes.Both,
                                                   RelativePositionAxes = Axes.X,
                                                   Anchor = Anchor.BottomLeft,
                                                   Origin = Anchor.BottomLeft,
-                                                  Width = 1f / length,
-                                                  X = (float)i / length
+                                                  Width = 1f / ChannelAmplitudes.AMPLITUDES_SIZE,
+                                                  X = (float)i / ChannelAmplitudes.AMPLITUDES_SIZE
                                               })
                             },
                         }
···
         {
             base.LoadComplete();
 
-            sample.Looping = true;
-            AddStep("start sample", () => sample.Play());
-            AddStep("stop sample", () => sample.Stop());
+            AddStep("start sample", () =>
+            {
+                channel = sample.Play();
+                channel.Looping = true;
+            });
+
+            AddStep("stop sample", () => channel.Stop());
         }
 
         protected override void Update()
         {
             base.Update();
 
-            var amplitudes = bassSample.CurrentAmplitudes;
+            if (channel == null)
+                return;
+
+            var amplitudes = channel.CurrentAmplitudes;
 
             rightChannel.Width = amplitudes.RightChannel * 0.5f;
             leftChannel.Width = amplitudes.LeftChannel * 0.5f;

osu.Framework.Tests/Visual/Audio/TestSceneSampleLooping.cs

···
 {
     public class TestSceneSampleLooping : FrameworkTestScene
     {
-        private SampleChannel sampleChannel;
+        private Sample sample;
+        private SampleChannel channel;
 
         [Resolved]
         private AudioManager audioManager { get; set; }
···
         public void SetUpSteps()
         {
             AddUntilStep("audio device ready", () => audioManager.IsLoaded);
-            AddStep("create looping sample", createLoopingSample);
+            AddStep("create looping sample", () =>
+            {
+                channel?.Dispose();
+                sample = audioManager.Samples.Get("tone.wav");
+            });
         }
 
         [Test]
···
         {
             playAndCheckSample();
 
-            AddStep("disable looping", () => sampleChannel.Looping = false);
-            AddUntilStep("ensure stops", () => !sampleChannel.Playing);
+            AddStep("disable looping", () => channel.Looping = false);
+            AddUntilStep("ensure stops", () => !channel.Playing);
         }
 
         [Test]
···
         {
             playAndCheckSample();
 
-            AddStep("set frequency to 0", () => sampleChannel.Frequency.Value = 0);
-            AddAssert("is still playing", () => sampleChannel.Playing);
+            AddStep("set frequency to 0", () => channel.Frequency.Value = 0);
+            AddAssert("is still playing", () => channel.Playing);
         }
 
         [Test]
         public void TestZeroFrequencyOnStart()
         {
-            AddStep("set frequency to 0", () => sampleChannel.Frequency.Value = 0);
+            AddStep("set frequency to 0", () => channel.Frequency.Value = 0);
             playAndCheckSample();
 
-            AddStep("set frequency to 1", () => sampleChannel.Frequency.Value = 1);
-            AddAssert("is still playing", () => sampleChannel.Playing);
+            AddStep("set frequency to 1", () => channel.Frequency.Value = 1);
+            AddAssert("is still playing", () => channel.Playing);
         }
 
         [Test]
···
         {
             stopAndCheckSample();
 
-            AddStep("set frequency to 0", () => sampleChannel.Frequency.Value = 0);
-            AddAssert("still stopped", () => !sampleChannel.Playing);
+            AddStep("set frequency to 0", () => channel.Frequency.Value = 0);
+            AddAssert("still stopped", () => !channel.Playing);
         }
 
         [TearDownSteps]
···
 
         private void playAndCheckSample()
         {
-            AddStep("play sample", () => sampleChannel.Play());
+            AddStep("play sample", () =>
+            {
+                channel = sample.Play();
+
+                // reduce volume of the tone due to how loud it normally is.
+                channel.Volume.Value = 0.05;
+                channel.Looping = true;
+            });
 
             // ensures that it is in fact looping given that the loaded sample length is very short.
             AddWaitStep("wait", 10);
-            AddAssert("is playing", () => sampleChannel.Playing);
+            AddAssert("is playing", () => channel.Playing);
         }
 
         private void stopAndCheckSample()
         {
-            AddStep("stop playing", () => sampleChannel.Stop());
-            AddUntilStep("stopped", () => !sampleChannel.Playing);
-        }
-
-        private void createLoopingSample()
-        {
-            sampleChannel?.Dispose();
-            sampleChannel = audioManager.Samples.Get("tone.wav");
-
-            // reduce volume of the tone due to how loud it normally is.
-            sampleChannel.Volume.Value = 0.05;
-            sampleChannel.Looping = true;
+            AddStep("stop playing", () => channel.Stop());
+            AddUntilStep("stopped", () => !channel.Playing);
         }
 
         protected override void Dispose(bool isDisposing)
         {
-            sampleChannel?.Dispose();
+            channel?.Dispose();
             base.Dispose(isDisposing);
         }
     }

osu.Framework.Tests/Visual/Audio/TestSceneSamples.cs

···
                 Played = true;
                 circle.ScaleTo(1.8f).ScaleTo(1, 600, Easing.OutQuint);
 
-                sample.Frequency.Value = 1 + Y / notes;
-                sample.Play();
+                var channel = sample.Play();
+                channel.Frequency.Value = 1 + Y / notes;
             }
         }
     }

osu.Framework/Audio/AudioCollectionManager.cs

···
     /// A collection of audio components which need central property control.
     /// </summary>
     public class AudioCollectionManager<T> : AdjustableAudioComponent, IBassAudio
-        where T : AdjustableAudioComponent
+        where T : AudioComponent
     {
         internal List<T> Items = new List<T>();
 
···
             {
                 if (Items.Contains(item)) return;
 
-                item.BindAdjustments(this);
+                (item as AdjustableAudioComponent)?.BindAdjustments(this);
+
                 Items.Add(item);
             });
         }

osu.Framework/Audio/Sample/ISample.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Audio.Sample
+{
+    public interface ISample
+    {
+        double Length { get; }
+
+        SampleChannel Play();
+    }
+}

osu.Framework/Audio/Sample/ISampleChannel.cs

···
     public interface ISampleChannel : IHasAmplitudes
     {
         /// <summary>
-        /// Start a playback of this sample.
-        /// </summary>
-        /// <param name="restart">Whether to restart the sample from the beginning. If true, any existing playback of the channel will be stopped.</param>
-        void Play(bool restart = true);
-
-        /// <summary>
         /// Stop playback and reset position to beginning of sample.
         /// </summary>
         void Stop();
···
         /// States if this sample should repeat.
         /// </summary>
         bool Looping { get; set; }
-
-        /// <summary>
-        /// The length of the underlying sample, in milliseconds.
-        /// </summary>
-        double Length { get; }
     }
 }

osu.Framework/Audio/Sample/ISampleStore.cs

···
 
 namespace osu.Framework.Audio.Sample
 {
-    public interface ISampleStore : IAdjustableResourceStore<SampleChannel>
+    public interface ISampleStore : IAdjustableResourceStore<Sample>
     {
         /// <summary>
         /// How many instances of a single sample should be allowed to playback concurrently before stopping the longest playing.

osu.Framework/Audio/Sample/Sample.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+
 namespace osu.Framework.Audio.Sample
 {
     public abstract class Sample : AudioComponent
     {
         public const int DEFAULT_CONCURRENCY = 2;
+
+        internal Action<SampleChannel> AddChannel;
 
         /// <summary>
         /// The length in milliseconds of this <see cref="Sample"/>.
···
         {
             PlaybackConcurrency = playbackConcurrency;
         }
+
+        public SampleChannel Play()
+        {
+            var channel = CreateChannel();
+
+            if (channel != null)
+                AddChannel?.Invoke(channel);
+
+            return channel;
+        }
+
+        protected abstract SampleChannel CreateChannel();
     }
 }

osu.Framework/Audio/Sample/SampleBass.cs

···
 
 using ManagedBass;
 using osu.Framework.Allocation;
-using System.Collections.Concurrent;
 using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using osu.Framework.Platform;
 
 namespace osu.Framework.Audio.Sample
 {
     internal sealed class SampleBass : Sample, IBassAudio
     {
-        private volatile int sampleId;
+        public int SampleId { get; private set; }
 
-        public override bool IsLoaded => sampleId != 0;
+        public override bool IsLoaded => SampleId != 0;
 
         private NativeMemoryTracker.NativeMemoryLease memoryLease;
 
-        internal SampleBass(byte[] data, ConcurrentQueue<Task> customPendingActions = null, int concurrency = DEFAULT_CONCURRENCY)
+        internal SampleBass(byte[] data, int concurrency = DEFAULT_CONCURRENCY)
             : base(concurrency)
         {
-            if (customPendingActions != null)
-                PendingActions = customPendingActions;
-
             if (data.Length > 0)
             {
                 EnqueueAction(() =>
                 {
-                    sampleId = loadSample(data);
+                    SampleId = loadSample(data);
                     memoryLease = NativeMemoryTracker.AddMemory(this, data.Length);
                 });
             }
···
         {
             if (IsLoaded)
             {
-                Bass.SampleFree(sampleId);
+                Bass.SampleFree(SampleId);
                 memoryLease?.Dispose();
             }
 
···
                 return;
 
             // counter-intuitively, this is the correct API to use to migrate a sample to a new device.
-            Bass.ChannelSetDevice(sampleId, deviceIndex);
+            Bass.ChannelSetDevice(SampleId, deviceIndex);
             BassUtils.CheckFaulted(true);
         }
-
-        public int CreateChannel() => Bass.SampleGetChannel(sampleId);
 
         private int loadSample(byte[] data)
         {
···
             using (var handle = new ObjectHandle<byte[]>(data, GCHandleType.Pinned))
                 return Bass.SampleLoad(handle.Address, 0, data.Length, PlaybackConcurrency, flags);
         }
+
+        protected override SampleChannel CreateChannel() => new SampleChannelBass(this);
     }
 }

osu.Framework/Audio/Sample/SampleChannel.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Statistics;
-using System;
 using osu.Framework.Audio.Track;
 
 namespace osu.Framework.Audio.Sample
 {
     public abstract class SampleChannel : AdjustableAudioComponent, ISampleChannel
     {
-        protected bool WasStarted;
-
-        protected Sample Sample { get; set; }
-
-        private readonly Action<SampleChannel> onPlay;
-
-        protected SampleChannel(Sample sample, Action<SampleChannel> onPlay)
-        {
-            Sample = sample ?? throw new ArgumentNullException(nameof(sample));
-            this.onPlay = onPlay;
-        }
-
-        public virtual void Play(bool restart = true)
-        {
-            if (IsDisposed)
-                throw new ObjectDisposedException(ToString(), "Can not play disposed samples.");
-
-            onPlay(this);
-            WasStarted = true;
-        }
-
         public virtual void Stop()
         {
-            if (IsDisposed)
-                throw new ObjectDisposedException(ToString(), "Can not stop disposed samples.");
         }
 
         protected override void Dispose(bool disposing)
···
 
         public abstract bool Playing { get; }
 
-        public virtual bool Played => WasStarted && !Playing;
-
-        public double Length => Sample.Length;
+        public virtual bool Played => !Playing;
 
         public override bool IsAlive => base.IsAlive && !Played;
 

osu.Framework/Audio/Sample/SampleChannelBass.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using ManagedBass;
 using osu.Framework.Audio.Track;
 
 namespace osu.Framework.Audio.Sample
 {
-    public sealed class SampleChannelBass : SampleChannel, IBassAudio
+    internal sealed class SampleChannelBass : SampleChannel, IBassAudio
     {
         private volatile int channel;
         private volatile bool playing;
-
-        public override bool IsLoaded => Sample.IsLoaded;
 
         private readonly BassRelativeFrequencyHandler relativeFrequencyHandler;
         private BassAmplitudeProcessor bassAmplitudeProcessor;
 
-        public SampleChannelBass(Sample sample, Action<SampleChannel> onPlay)
-            : base(sample, onPlay)
+        public SampleChannelBass(SampleBass sample)
         {
             relativeFrequencyHandler = new BassRelativeFrequencyHandler
             {
                 FrequencyChangedToZero = () => Bass.ChannelPause(channel),
                 FrequencyChangedFromZero = () => Bass.ChannelPlay(channel),
             };
+
+            EnqueueAction(() =>
+            {
+                channel = Bass.SampleGetChannel(sample.SampleId);
+                if (channel == 0)
+                    return;
+
+                Bass.ChannelSetAttribute(channel, ChannelAttribute.NoRamp, 1);
+                setLoopFlag(Looping);
+
+                relativeFrequencyHandler.SetChannel(channel);
+                bassAmplitudeProcessor?.SetChannel(channel);
+
+                // ensure state is correct before starting.
+                InvalidateState();
+
+                if (channel != 0 && !relativeFrequencyHandler.IsFrequencyZero)
+                    Bass.ChannelPlay(channel, true);
+            });
+
+            // Needs to happen on the main thread such that
+            // Played does not become true for a short moment.
+            playing = true;
         }
 
         void IBassAudio.UpdateDevice(int deviceIndex)
···
             }
         }
 
-        public override void Play(bool restart = true)
-        {
-            base.Play(restart);
-
-            EnqueueAction(() =>
-            {
-                if (!IsLoaded)
-                {
-                    channel = 0;
-                    return;
-                }
-
-                bool existingChannelAvailable = Bass.ChannelIsActive(channel) != PlaybackState.Stopped;
-
-                if (existingChannelAvailable)
-                {
-                    // if restart is not requested and the sample is currently playing, nothing needs to be done.
-                    if (!restart)
-                        return;
-
-                    Stop();
-                }
-
-                channel = ((SampleBass)Sample).CreateChannel();
-
-                Bass.ChannelSetAttribute(channel, ChannelAttribute.NoRamp, 1);
-                setLoopFlag(Looping);
-
-                relativeFrequencyHandler.SetChannel(channel);
-                bassAmplitudeProcessor?.SetChannel(channel);
-
-                // ensure state is correct before starting.
-                InvalidateState();
-
-                if (channel != 0 && !relativeFrequencyHandler.IsFrequencyZero)
-                    Bass.ChannelPlay(channel, restart);
-            });
-
-            // Needs to happen on the main thread such that
-            // Played does not become true for a short moment.
-            playing = true;
-        }
-
         protected override void UpdateState()
         {
             playing = channel != 0 && Bass.ChannelIsActive(channel) != 0;
+
             base.UpdateState();
 
             bassAmplitudeProcessor?.Update();

osu.Framework/Audio/Sample/SampleChannelVirtual.cs

···
     /// </summary>
     public sealed class SampleChannelVirtual : SampleChannel
     {
-        public SampleChannelVirtual()
-            : base(new SampleVirtual(), _ => { })
+        private volatile bool playing = true;
+
+        public override bool Playing => playing;
+
+        public override void Stop()
         {
+            base.Stop();
+            playing = false;
         }
+    }
 
-        public override bool Playing => false;
-
-        private class SampleVirtual : Sample
+    public sealed class SampleVirtual : Sample
+    {
+        public SampleVirtual(int playbackConcurrency = DEFAULT_CONCURRENCY)
+            : base(playbackConcurrency)
         {
         }
+
+        protected override SampleChannel CreateChannel() => new SampleChannelVirtual();
     }
 }

osu.Framework/Audio/Sample/SampleStore.cs

···
 
 namespace osu.Framework.Audio.Sample
 {
-    internal class SampleStore : AudioCollectionManager<AdjustableAudioComponent>, ISampleStore
+    internal class SampleStore : AudioCollectionManager<AudioComponent>, ISampleStore
     {
         private readonly IResourceStore<byte[]> store;
 
···
             (store as ResourceStore<byte[]>)?.AddExtension(@"mp3");
         }
 
-        public SampleChannel Get(string name)
+        public Sample Get(string name)
         {
             if (IsDisposed) throw new ObjectDisposedException($"Cannot retrieve items for an already disposed {nameof(SampleStore)}");
 
···
 
             lock (sampleCache)
             {
-                SampleChannel channel = null;
+                if (sampleCache.TryGetValue(name, out Sample sample))
+                    return sample;
 
-                if (!sampleCache.TryGetValue(name, out Sample sample))
-                {
-                    this.LogIfNonBackgroundThread(name);
+                this.LogIfNonBackgroundThread(name);
+
+                byte[] data = store.Get(name);
 
-                    byte[] data = store.Get(name);
-                    sample = sampleCache[name] = data == null ? null : new SampleBass(data, PendingActions, PlaybackConcurrency);
-                }
+                sample = sampleCache[name] = data == null
+                    ? null
+                    : new SampleBass(data, PlaybackConcurrency) { AddChannel = AddItem };
 
                 if (sample != null)
-                {
-                    channel = new SampleChannelBass(sample, AddItem);
-                }
+                    AddItem(sample);
 
-                return channel;
+                return sample;
             }
         }
 
-        public Task<SampleChannel> GetAsync(string name) => Task.Run(() => Get(name));
+        public Task<Sample> GetAsync(string name) => Task.Run(() => Get(name));
 
         internal override void UpdateDevice(int deviceIndex)
         {

osu.Framework/Graphics/Audio/DrawableSample.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using JetBrains.Annotations;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
 
···
     /// <summary>
     /// A <see cref="SampleChannel"/> wrapper to allow insertion in the draw hierarchy to allow transforms, lifetime management etc.
     /// </summary>
-    public class DrawableSample : DrawableAudioWrapper, ISampleChannel
+    public class DrawableSample : DrawableAudioWrapper, ISample
     {
-        private readonly SampleChannel channel;
+        private readonly Sample sample;
+        private readonly bool disposeChannelsOnDisposal;
 
         /// <summary>
         /// Construct a new drawable sample instance.
         /// </summary>
-        /// <param name="channel">The audio sample to wrap.</param>
-        /// <param name="disposeChannelOnDisposal">Whether the sample should be automatically disposed on drawable disposal/expiry.</param>
-        public DrawableSample(SampleChannel channel, bool disposeChannelOnDisposal = true)
-            : base(channel, disposeChannelOnDisposal)
+        /// <param name="sample">The audio sample to wrap.</param>
+        /// <param name="disposeChannelsOnDisposal">Whether the sample channels should be automatically disposed on drawable disposal/expiry.</param>
+        public DrawableSample(Sample sample, bool disposeChannelsOnDisposal = true)
+            : base(Empty())
         {
-            this.channel = channel;
+            this.sample = sample;
+            this.disposeChannelsOnDisposal = disposeChannelsOnDisposal;
         }
 
-        public void Play(bool restart = true) => channel.Play(restart);
+        public SampleChannel Play()
+        {
+            var channel = sample.Play();
+            AddInternal(new DrawableSampleChannel(channel, disposeChannelsOnDisposal));
+            return channel;
+        }
 
-        public void Stop() => channel.Stop();
+        public double Length => sample.Length;
 
-        public bool Playing => channel.Playing;
+        private class DrawableSampleChannel : DrawableAudioWrapper, ISampleChannel
+        {
+            [NotNull]
+            private readonly SampleChannel channel;
 
-        public bool Played => channel.Played;
+            /// <param name="channel">The sample channel to wrap.</param>
+            /// <param name="disposeChannelOnDisposal">Whether the channel should be automatically disposed on drawable disposal/expiry.</param>
+            public DrawableSampleChannel([NotNull] SampleChannel channel, bool disposeChannelOnDisposal = true)
+                : base(channel, disposeChannelOnDisposal)
+            {
+                this.channel = channel;
+            }
+
+            public ChannelAmplitudes CurrentAmplitudes => channel.CurrentAmplitudes;
+
+            public void Stop() => channel.Stop();
 
-        public bool Looping
-        {
-            get => channel.Looping;
-            set => channel.Looping = value;
-        }
+            public bool Playing => channel.Playing;
 
-        public double Length => channel.Length;
+            public bool Played => channel.Played;
 
-        public ChannelAmplitudes CurrentAmplitudes => channel.CurrentAmplitudes;
+            public bool Looping
+            {
+                get => channel.Looping;
+                set => channel.Looping = value;
+            }
+        }
     }
 }