Remove extra handling of audio file and loading the whole file to memory

[NeoCoderMatrix86]

Is your feature request related to a problem? Please describe.
Large audiofiles can take seconds to load, while editing the cuesheet. Please load just what is needed.

Describe the solution you'd like
Loading metadata like length in milliseconds.

• Use Browser Audio API
• Remove ATL library
• Remove stream from audiofile

[NeoCoderMatrix86]

Copilot states that mostly the first 256 KB should work for loading the metadata. Something like this should be an idea:

byte[] buffer = new byte[256 * 1024];
int bytesRead = ContentStream.Read(buffer, 0, buffer.Length);
var headerStream = new MemoryStream(buffer, 0, bytesRead);
var track = new ATL.Track(headerStream, AudioCodec.MimeType);
Duration = new TimeSpan(0, 0, track.Duration);

Otherwise a seekable stream should be considered.

/// <summary>
/// Wrapper for BrowserHttpReadStream to make it seekable
/// Caches only the parts of the file that are actually read
/// </summary>
public class SeekableHttpStream : Stream
{
    private readonly Stream _sourceStream;
    private readonly Dictionary<long, byte[]> _cache = new();
    private long _position = 0;
    private long? _length = null;
    private readonly int _bufferSize = 65536; // 64 KB chunks

    public SeekableHttpStream(Stream sourceStream)
    {
        _sourceStream = sourceStream;
    }

    public override bool CanRead => true;
    public override bool CanSeek => true;
    public override bool CanWrite => false;

    public override long Length
    {
        get
        {
            if (_length == null)
            {
                // Read entire source once to determine length
                var buffer = new byte[_bufferSize];
                int bytesRead;
                long totalBytes = 0;
                while ((bytesRead = _sourceStream.Read(buffer, 0, _bufferSize)) > 0)
                {
                    var chunkKey = totalBytes;
                    var chunk = new byte[bytesRead];
                    Array.Copy(buffer, chunk, bytesRead);
                    _cache[chunkKey] = chunk;
                    totalBytes += bytesRead;
                }
                _length = totalBytes;
            }
            return _length.Value;
        }
    }

    public override long Position
    {
        get => _position;
        set => _position = value;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        long chunkKey = (_position / _bufferSize) * _bufferSize;
        int inChunkOffset = (int)(_position % _bufferSize);

        if (!_cache.ContainsKey(chunkKey))
        {
            // Load the chunk if not cached
            var tempBuffer = new byte[_bufferSize];
            int bytesRead = _sourceStream.Read(tempBuffer, 0, _bufferSize);
            if (bytesRead > 0)
            {
                var chunk = new byte[bytesRead];
                Array.Copy(tempBuffer, chunk, bytesRead);
                _cache[chunkKey] = chunk;
            }
        }

        if (!_cache.ContainsKey(chunkKey))
            return 0;

        var cachedChunk = _cache[chunkKey];
        int toCopy = Math.Min(count, cachedChunk.Length - inChunkOffset);
        Array.Copy(cachedChunk, inChunkOffset, buffer, offset, toCopy);
        _position += toCopy;
        return toCopy;
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        switch (origin)
        {
            case SeekOrigin.Begin:
                _position = offset;
                break;
            case SeekOrigin.Current:
                _position += offset;
                break;
            case SeekOrigin.End:
                _position = Length + offset;
                break;
        }
        return _position;
    }

    public override void Flush() { }
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
}

[NeoCoderMatrix86]

Using Browser Audio API works in milliseconds:

function getAudioDurationFromFile(url) {
    return new Promise((resolve, reject) => {
        const audio = new Audio();

        audio.preload = "metadata";
        audio.src = url;

        audio.onloadedmetadata = () => {
            resolve(audio.duration);
        };

        audio.onerror = (e) => {
            reject(e);
        };
    });
}

usage:
var duration = await _jsRuntime.InvokeAsync<double>("getAudioDurationFromFile", audioFileObjectURL);
Returns duration in seconds (double).