chore: SDL3 (ryubing/ryujinx!207)

See merge request ryubing/ryujinx!207

src/Ryujinx.Audio.Backends.SDL3/Ryujinx.Audio.Backends.SDL3.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DefaultItemExcludes>$(DefaultItemExcludes);._*</DefaultItemExcludes>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Ryujinx.Audio\Ryujinx.Audio.csproj" />
+    <ProjectReference Include="..\Ryujinx.SDL3.Common\Ryujinx.SDL3.Common.csproj" />
+  </ItemGroup>
+
+</Project>

src/Ryujinx.Audio.Backends.SDL3/SDL3AudioBuffer.cs

@@ -0,0 +1,16 @@
+namespace Ryujinx.Audio.Backends.SDL3
+{
+    class SDL3AudioBuffer
+    {
+        public readonly ulong DriverIdentifier;
+        public readonly ulong SampleCount;
+        public ulong SamplePlayed;
+
+        public SDL3AudioBuffer(ulong driverIdentifier, ulong sampleCount)
+        {
+            DriverIdentifier = driverIdentifier;
+            SampleCount = sampleCount;
+            SamplePlayed = 0;
+        }
+    }
+}

src/Ryujinx.Audio.Backends.SDL3/SDL3HardwareDeviceDriver.cs

@@ -0,0 +1,207 @@
+using Ryujinx.Audio.Common;
+using Ryujinx.Audio.Integration;
+using Ryujinx.Common.Logging;
+using Ryujinx.Memory;
+using Ryujinx.SDL3.Common;
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using static Ryujinx.Audio.Integration.IHardwareDeviceDriver;
+using SDL;
+using static SDL.SDL3;
+using System.Runtime.InteropServices;
+
+
+namespace Ryujinx.Audio.Backends.SDL3
+{
+
+    using unsafe SDL_AudioStreamCallbackPointer = delegate* unmanaged[Cdecl]<nint, SDL_AudioStream*, int, int, void>;
+
+    public class SDL3HardwareDeviceDriver : IHardwareDeviceDriver
+    {
+        private readonly ManualResetEvent _updateRequiredEvent;
+        private readonly ManualResetEvent _pauseEvent;
+        private readonly ConcurrentDictionary<SDL3HardwareDeviceSession, byte> _sessions;
+
+        private readonly bool _supportSurroundConfiguration;
+
+        public float Volume { get; set; }
+
+        public unsafe SDL3HardwareDeviceDriver()
+        {
+            _updateRequiredEvent = new ManualResetEvent(false);
+            _pauseEvent = new ManualResetEvent(true);
+            _sessions = new ConcurrentDictionary<SDL3HardwareDeviceSession, byte>();
+
+            SDL3Driver.Instance.Initialize();
+
+            SDL_AudioSpec spec;
+            if (!SDL_GetAudioDeviceFormat(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, null))
+            {
+                Logger.Error?.Print(LogClass.Application,
+                    $"SDL_GetDefaultAudioInfo failed with error \"{SDL_GetError()}\"");
+
+                _supportSurroundConfiguration = true;
+            }
+            else
+            {
+                _supportSurroundConfiguration = spec.channels >= 6;
+            }
+
+            Volume = 1f;
+        }
+
+        public static bool IsSupported => IsSupportedInternal();
+
+        private unsafe static bool IsSupportedInternal()
+        {
+            SDL_AudioStream* device = OpenStream(SampleFormat.PcmInt16, Constants.TargetSampleRate, Constants.ChannelCountMax, Constants.TargetSampleCount, null);
+
+            if (device != null)
+            {
+                SDL_DestroyAudioStream(device);
+            }
+
+            return device != null;
+        }
+
+        public ManualResetEvent GetUpdateRequiredEvent()
+        {
+            return _updateRequiredEvent;
+        }
+
+        public ManualResetEvent GetPauseEvent()
+        {
+            return _pauseEvent;
+        }
+
+        public IHardwareDeviceSession OpenDeviceSession(Direction direction, IVirtualMemoryManager memoryManager, SampleFormat sampleFormat, uint sampleRate, uint channelCount)
+        {
+            if (channelCount == 0)
+            {
+                channelCount = 2;
+            }
+
+            if (sampleRate == 0)
+            {
+                sampleRate = Constants.TargetSampleRate;
+            }
+
+            if (direction != Direction.Output)
+            {
+                throw new NotImplementedException("Input direction is currently not implemented on SDL3 backend!");
+            }
+
+            SDL3HardwareDeviceSession session = new(this, memoryManager, sampleFormat, sampleRate, channelCount);
+
+            _sessions.TryAdd(session, 0);
+
+            return session;
+        }
+
+        internal bool Unregister(SDL3HardwareDeviceSession session)
+        {
+            return _sessions.TryRemove(session, out _);
+        }
+
+        private static SDL_AudioSpec GetSDL3Spec(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount)
+        {
+            return new SDL_AudioSpec
+            {
+                channels = (byte)requestedChannelCount,
+                format = GetSDL3Format(requestedSampleFormat),
+                freq = (int)requestedSampleRate,
+            };
+        }
+
+        internal static SDL_AudioFormat GetSDL3Format(SampleFormat format)
+        {
+            return format switch
+            {
+                SampleFormat.PcmInt8 => SDL_AudioFormat.SDL_AUDIO_S8,
+                SampleFormat.PcmInt16 => SDL_AudioFormat.SDL_AUDIO_S16LE,
+                SampleFormat.PcmInt32 => SDL_AudioFormat.SDL_AUDIO_S32LE,
+                SampleFormat.PcmFloat => SDL_AudioFormat.SDL_AUDIO_F32LE,
+                _ => throw new ArgumentException($"Unsupported sample format {format}"),
+            };
+        }
+
+        internal unsafe static SDL_AudioStream* OpenStream(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, uint sampleCount, SDL3HardwareDeviceSession.SDL_AudioStreamCallback callback)
+        {
+            SDL_AudioSpec desired = GetSDL3Spec(requestedSampleFormat, requestedSampleRate, requestedChannelCount);
+            SDL_AudioSpec got = desired;
+            var pCallback = callback != null ? (SDL_AudioStreamCallbackPointer)Marshal.GetFunctionPointerForDelegate(callback) : null;
+
+            // From SDL 3 and on, SDL requires us to set this as a hint
+            SDL_SetHint(SDL_HINT_AUDIO_DEVICE_SAMPLE_FRAMES, $"{sampleCount}");
+            SDL_AudioStream* device = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &got, pCallback, 0);
+            Console.WriteLine(got.freq);
+
+            if (device == null)
+            {
+                Logger.Error?.Print(LogClass.Application, $"SDL3 open audio device initialization failed with error \"{SDL_GetError()}\"");
+
+                return null;
+            }
+
+            bool isValid = got.format == desired.format && got.freq == desired.freq && got.channels == desired.channels;
+
+            if (!isValid)
+            {
+                Logger.Error?.Print(LogClass.Application, "SDL3 open audio device is not valid");
+                SDL_DestroyAudioStream(device);
+
+                return null;
+            }
+
+            return device;
+        }
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                foreach (SDL3HardwareDeviceSession session in _sessions.Keys)
+                {
+                    session.Dispose();
+                }
+
+                SDL3Driver.Instance.Dispose();
+
+                _pauseEvent.Dispose();
+            }
+        }
+
+        public bool SupportsSampleRate(uint sampleRate)
+        {
+            return true;
+        }
+
+        public bool SupportsSampleFormat(SampleFormat sampleFormat)
+        {
+            return sampleFormat != SampleFormat.PcmInt24;
+        }
+
+        public bool SupportsChannelCount(uint channelCount)
+        {
+            if (channelCount == 6)
+            {
+                return _supportSurroundConfiguration;
+            }
+
+            return true;
+        }
+
+        public bool SupportsDirection(Direction direction)
+        {
+            // TODO: add direction input when supported.
+            return direction == Direction.Output;
+        }
+    }
+}

src/Ryujinx.Audio.Backends.SDL3/SDL3HardwareDeviceSession.cs

@@ -0,0 +1,248 @@
+using Ryujinx.Audio.Backends.Common;
+using Ryujinx.Audio.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
+using Ryujinx.Memory;
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using SDL;
+using static SDL.SDL3;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Backends.SDL3
+{
+
+
+
+    unsafe class SDL3HardwareDeviceSession : HardwareDeviceSessionOutputBase
+    {
+        private readonly SDL3HardwareDeviceDriver _driver;
+        private readonly ConcurrentQueue<SDL3AudioBuffer> _queuedBuffers;
+        private readonly DynamicRingBuffer _ringBuffer;
+        private ulong _playedSampleCount;
+        private readonly ManualResetEvent _updateRequiredEvent;
+        private SDL_AudioStream* _outputStream;
+        private bool _hasSetupError;
+        private readonly SDL_AudioStreamCallback _callbackDelegate;
+        private readonly int _bytesPerFrame;
+        private uint _sampleCount;
+        private bool _started;
+        private float _volume;
+        private readonly SDL_AudioFormat _nativeSampleFormat;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void SDL_AudioStreamCallback(nint session, SDL_AudioStream* stream, int stream_count, int device_count);
+
+        public SDL3HardwareDeviceSession(SDL3HardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount)
+        {
+            _driver = driver;
+            _updateRequiredEvent = _driver.GetUpdateRequiredEvent();
+            _queuedBuffers = new ConcurrentQueue<SDL3AudioBuffer>();
+            _ringBuffer = new DynamicRingBuffer();
+            _callbackDelegate = Update;
+            _bytesPerFrame = BackendHelper.GetSampleSize(RequestedSampleFormat) * (int)RequestedChannelCount;
+            _nativeSampleFormat = SDL3HardwareDeviceDriver.GetSDL3Format(RequestedSampleFormat);
+            _sampleCount = uint.MaxValue;
+            _started = false;
+            _volume = 1f;
+        }
+
+        private void EnsureAudioStreamSetup(AudioBuffer buffer)
+        {
+            uint bufferSampleCount = (uint)GetSampleCount(buffer);
+            bool needAudioSetup = (_outputStream == null && !_hasSetupError) ||
+                (bufferSampleCount >= Constants.TargetSampleCount && bufferSampleCount < _sampleCount);
+
+            if (needAudioSetup)
+            {
+                _sampleCount = Math.Max(Constants.TargetSampleCount, bufferSampleCount);
+
+                SDL_AudioStream* newOutputStream = SDL3HardwareDeviceDriver.OpenStream(RequestedSampleFormat, RequestedSampleRate, RequestedChannelCount, _sampleCount, _callbackDelegate);
+
+                _hasSetupError = newOutputStream == null;
+
+                if (!_hasSetupError)
+                {
+                    if (_outputStream != null)
+                    {
+                        SDL_DestroyAudioStream(_outputStream);
+                    }
+
+                    _outputStream = newOutputStream;
+
+                    if (_started) {
+                        SDL_ResumeAudioStreamDevice(_outputStream);
+                    } else {
+                        SDL_PauseAudioStreamDevice(_outputStream);
+                    }
+
+                    Logger.Info?.Print(LogClass.Audio, $"New audio stream setup with a target sample count of {_sampleCount}");
+                }
+            }
+        }
+
+        private unsafe void Update(nint userdata, SDL_AudioStream* streamDevice, int additionalAmount, int totalAmmount)
+        {
+            using SpanOwner<byte> stream = SpanOwner<byte>.Rent(additionalAmount);
+            Span<byte> streamSpan = stream.Span;
+
+
+            int maxFrameCount = (int)GetSampleCount(additionalAmount);
+            int bufferedFrames = _ringBuffer.Length / _bytesPerFrame;
+
+            int frameCount = Math.Min(bufferedFrames, maxFrameCount);
+
+            if (frameCount == 0)
+            {
+                // SDL3 left the responsibility to the user to clear the buffer.
+                streamSpan.Clear();
+
+                return;
+            }
+
+            using SpanOwner<byte> samplesOwner = SpanOwner<byte>.Rent(frameCount * _bytesPerFrame);
+
+            Span<byte> samples = samplesOwner.Span;
+
+            _ringBuffer.Read(samples, 0, samples.Length);
+
+            // Zero the dest buffer
+            streamSpan.Clear();
+
+            fixed (byte* pStreamDst = streamSpan) {
+                fixed (byte* pStreamSrc = samples)
+                {
+
+                    // Apply volume to written data
+                    SDL_MixAudio(pStreamDst, pStreamSrc, _nativeSampleFormat, (uint)samples.Length, _driver.Volume * _volume);
+                    SDL_PutAudioStreamData(streamDevice, (nint)pStreamDst, additionalAmount);
+                }
+            }
+
+            ulong sampleCount = GetSampleCount(samples.Length);
+
+            ulong availaibleSampleCount = sampleCount;
+
+            bool needUpdate = false;
+
+            while (availaibleSampleCount > 0 && _queuedBuffers.TryPeek(out SDL3AudioBuffer driverBuffer))
+            {
+                ulong sampleStillNeeded = driverBuffer.SampleCount - Interlocked.Read(ref driverBuffer.SamplePlayed);
+                ulong playedAudioBufferSampleCount = Math.Min(sampleStillNeeded, availaibleSampleCount);
+
+                ulong currentSamplePlayed = Interlocked.Add(ref driverBuffer.SamplePlayed, playedAudioBufferSampleCount);
+                availaibleSampleCount -= playedAudioBufferSampleCount;
+
+                if (currentSamplePlayed == driverBuffer.SampleCount)
+                {
+                    _queuedBuffers.TryDequeue(out _);
+
+                    needUpdate = true;
+                }
+
+                Interlocked.Add(ref _playedSampleCount, playedAudioBufferSampleCount);
+            }
+
+            // Notify the output if needed.
+            if (needUpdate)
+            {
+                _updateRequiredEvent.Set();
+            }
+        }
+
+        public override ulong GetPlayedSampleCount()
+        {
+            return Interlocked.Read(ref _playedSampleCount);
+        }
+
+        public override float GetVolume()
+        {
+            return _volume;
+        }
+
+        public override void PrepareToClose() { }
+
+        public override void QueueBuffer(AudioBuffer buffer)
+        {
+            EnsureAudioStreamSetup(buffer);
+
+            if (_outputStream != null)
+            {
+                SDL3AudioBuffer driverBuffer = new(buffer.DataPointer, GetSampleCount(buffer));
+
+                _ringBuffer.Write(buffer.Data, 0, buffer.Data.Length);
+
+                _queuedBuffers.Enqueue(driverBuffer);
+            }
+            else
+            {
+                Interlocked.Add(ref _playedSampleCount, GetSampleCount(buffer));
+
+                _updateRequiredEvent.Set();
+            }
+        }
+
+        public override void SetVolume(float volume)
+        {
+            _volume = volume;
+        }
+
+        public override void Start()
+        {
+            if (!_started)
+            {
+                if (_outputStream != null)
+                {
+                    SDL_ResumeAudioStreamDevice(_outputStream);
+                }
+
+                _started = true;
+            }
+        }
+
+        public override void Stop()
+        {
+            if (_started)
+            {
+                if (_outputStream != null)
+                {
+                    SDL_PauseAudioStreamDevice(_outputStream);
+                }
+
+                _started = false;
+            }
+        }
+
+        public override void UnregisterBuffer(AudioBuffer buffer) { }
+
+        public override bool WasBufferFullyConsumed(AudioBuffer buffer)
+        {
+            if (!_queuedBuffers.TryPeek(out SDL3AudioBuffer driverBuffer))
+            {
+                return true;
+            }
+
+            return driverBuffer.DriverIdentifier != buffer.DataPointer;
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && _driver.Unregister(this))
+            {
+                PrepareToClose();
+                Stop();
+
+                if (_outputStream != null)
+                {
+                    SDL_DestroyAudioStream(_outputStream);
+                }
+            }
+        }
+
+        public override void Dispose()
+        {
+            Dispose(true);
+        }
+    }
+}