Return false if attempting to seek to end in TrackBass (#2499)

Return false if attempting to seek to end in TrackBass

osu.Framework.Tests/Audio/TrackBassTest.cs

···
         [Test]
         public void TestSeekToEndFails()
         {
-            track.SeekAsync(track.Length);
+            bool? success = null;
+
+            runOnAudioThread(() => { success = track.Seek(track.Length); });
             updateTrack();
 
             Assert.AreEqual(0, track.CurrentTime);
+            Assert.IsFalse(success);
         }
 
         [Test]

osu.Framework/Audio/Track/TrackBass.cs

···
 {
     public sealed class TrackBass : Track, IBassAudio, IHasPitchAdjust
     {
+        public const int BYTES_PER_SAMPLE = 4;
+
         private AsyncBufferStream dataStream;
 
         /// <summary>
···
         private bool isPlayed;
 
         private long byteLength;
+
+        /// <summary>
+        /// The last position that a seek will succeed for.
+        /// </summary>
+        private double lastSeekablePosition;
 
         private FileCallbacks fileCallbacks;
         private SyncCallback stopCallback;
···
                 if (success)
                 {
                     Length = seconds * 1000;
+
+                    // Bass does not allow seeking to the end of the track, so the last available position is 1 sample before.
+                    lastSeekablePosition = Bass.ChannelBytes2Seconds(activeStream, byteLength - BYTES_PER_SAMPLE) * 1000;
 
                     Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Frequency, out float frequency);
                     initialFrequency = frequency;
···
         {
             // At this point the track may not yet be loaded which is indicated by a 0 length.
             // In that case we still want to return true, hence the conservative length.
-            double conservativeLength = Length == 0 ? double.MaxValue : Length;
+            double conservativeLength = Length == 0 ? double.MaxValue : lastSeekablePosition;
             double conservativeClamped = MathHelper.Clamp(seek, 0, conservativeLength);
 
             await EnqueueAction(() =>

osu.Framework/Audio/Track/Waveform.cs

···
         /// </summary>
         private const int points_per_iteration = 100000;
 
-        private const int bytes_per_sample = 4;
-
         /// <summary>
         /// FFT1024 gives ~40hz accuracy.
         /// </summary>
···
                 // Each "point" is generated from a number of samples, each sample contains a number of channels
                 int samplesPerPoint = (int)(info.Frequency * resolution * info.Channels);
 
-                int bytesPerPoint = samplesPerPoint * bytes_per_sample;
+                int bytesPerPoint = samplesPerPoint * TrackBass.BYTES_PER_SAMPLE;
 
                 points.Capacity = (int)(length / bytesPerPoint);
 
                 // Each iteration pulls in several samples
                 int bytesPerIteration = bytesPerPoint * points_per_iteration;
-                var sampleBuffer = new float[bytesPerIteration / bytes_per_sample];
+                var sampleBuffer = new float[bytesPerIteration / TrackBass.BYTES_PER_SAMPLE];
 
                 // Read sample data
                 while (length > 0)
                 {
                     length = Bass.ChannelGetData(decodeStream, sampleBuffer, bytesPerIteration);
-                    int samplesRead = (int)(length / bytes_per_sample);
+                    int samplesRead = (int)(length / TrackBass.BYTES_PER_SAMPLE);
 
                     // Each point is composed of multiple samples
                     for (int i = 0; i < samplesRead; i += samplesPerPoint)