Bsd: Implement Select (#4017)

* bsd: Add gdkchan's Select implementation

Co-authored-by: TSRBerry <20988865+tsrberry@users.noreply.github.com>

* bsd: Fix Select() causing a crash with an ArgumentException

.NET Sockets have to be used for the Select() call

* bsd: Make Select more generic

* bsd: Adjust namespaces and remove unused imports

* bsd: Fix NullReferenceException in Select

Co-authored-by: gdkchan <gab.dark.100@gmail.com>

.editorconfig

@@ -89,6 +89,7 @@ csharp_style_conditional_delegate_call = true:suggestion
 # Modifier preferences
 csharp_prefer_static_local_function = true:suggestion
 csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent
+csharp_style_prefer_readonly_struct = true
 
 # Code-block preferences
 csharp_prefer_braces = true:silent

.github/workflows/release.yml

@@ -11,6 +11,7 @@ on:
       - '*.yml'
       - 'README.md'
 
+concurrency: release
 
 jobs:
   release:

ARMeilleure/CodeGen/RegisterAllocators/AllocationResult.cs

@@ -1,6 +1,6 @@
 namespace ARMeilleure.CodeGen.RegisterAllocators
 {
-    struct AllocationResult
+    readonly struct AllocationResult
     {
         public int IntUsedRegisters { get; }
         public int VecUsedRegisters { get; }

ARMeilleure/CodeGen/RegisterAllocators/CopyResolver.cs

@@ -11,7 +11,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
     {
         private class ParallelCopy
         {
-            private struct Copy
+            private readonly struct Copy
             {
                 public Register Dest   { get; }
                 public Register Source { get; }

ARMeilleure/CodeGen/RegisterAllocators/HybridAllocator.cs

@@ -11,7 +11,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
 {
     class HybridAllocator : IRegisterAllocator
     {
-        private struct BlockInfo
+        private readonly struct BlockInfo
         {
             public bool HasCall { get; }
 

ARMeilleure/CodeGen/RegisterAllocators/RegisterMasks.cs

@@ -3,7 +3,7 @@ using System;
 
 namespace ARMeilleure.CodeGen.RegisterAllocators
 {
-    struct RegisterMasks
+    readonly struct RegisterMasks
     {
         public int IntAvailableRegisters   { get; }
         public int VecAvailableRegisters   { get; }

ARMeilleure/CodeGen/X86/IntrinsicInfo.cs

@@ -1,6 +1,6 @@
 namespace ARMeilleure.CodeGen.X86
 {
-    struct IntrinsicInfo
+    readonly struct IntrinsicInfo
     {
         public X86Instruction Inst { get; }
         public IntrinsicType  Type { get; }

ARMeilleure/Decoders/InstDescriptor.cs

@@ -2,7 +2,7 @@ using ARMeilleure.Instructions;
 
 namespace ARMeilleure.Decoders
 {
-    struct InstDescriptor
+    readonly struct InstDescriptor
     {
         public static InstDescriptor Undefined => new InstDescriptor(InstName.Und, InstEmit.Und);
 

ARMeilleure/Decoders/OpCodeTable.cs

@@ -11,7 +11,7 @@ namespace ARMeilleure.Decoders
 
         private const int FastLookupSize = 0x1000;
 
-        private struct InstInfo
+        private readonly struct InstInfo
         {
             public int Mask  { get; }
             public int Value { get; }
@@ -1341,7 +1341,7 @@ namespace ARMeilleure.Decoders
         {
             string reversedEncoding = encoding.Substring(16) + encoding.Substring(0, 16);
             MakeOp reversedMakeOp =
-                (InstDescriptor inst, ulong address, int opCode)
+                (inst, address, opCode)
                     => makeOp(inst, address, (int)BitOperations.RotateRight((uint)opCode, 16));
             Set(reversedEncoding, AllInstT32, new InstDescriptor(name, emitter), reversedMakeOp);
         }

ARMeilleure/Diagnostics/Symbols.cs

@@ -6,7 +6,7 @@ namespace ARMeilleure.Diagnostics
 {
     static class Symbols
     {
-        private struct RangedSymbol
+        private readonly struct RangedSymbol
         {
             public readonly ulong Start;
             public readonly ulong End;

ARMeilleure/IntermediateRepresentation/PhiOperation.cs

@@ -3,7 +3,7 @@ using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
 
 namespace ARMeilleure.IntermediateRepresentation
 {
-    struct PhiOperation
+    readonly struct PhiOperation
     {
         private readonly Operation _operation;
 

ARMeilleure/IntermediateRepresentation/Register.cs

@@ -2,7 +2,7 @@ using System;
 
 namespace ARMeilleure.IntermediateRepresentation
 {
-    struct Register : IEquatable<Register>
+    readonly struct Register : IEquatable<Register>
     {
         public int Index { get; }
 

ARMeilleure/Translation/Cache/CacheEntry.cs

@@ -4,7 +4,7 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace ARMeilleure.Translation.Cache
 {
-    struct CacheEntry : IComparable<CacheEntry>
+    readonly struct CacheEntry : IComparable<CacheEntry>
     {
         public int Offset { get; }
         public int Size   { get; }

ARMeilleure/Translation/Cache/CacheMemoryAllocator.cs

@@ -6,7 +6,7 @@ namespace ARMeilleure.Translation.Cache
 {
     class CacheMemoryAllocator
     {
-        private struct MemoryBlock : IComparable<MemoryBlock>
+        private readonly struct MemoryBlock : IComparable<MemoryBlock>
         {
             public int Offset { get; }
             public int Size { get; }

ARMeilleure/Translation/CompilerContext.cs

@@ -2,7 +2,7 @@ using ARMeilleure.IntermediateRepresentation;
 
 namespace ARMeilleure.Translation
 {
-    struct CompilerContext
+    readonly struct CompilerContext
     {
         public ControlFlowGraph Cfg { get; }
 

ARMeilleure/Translation/RegisterUsage.cs

@@ -14,7 +14,7 @@ namespace ARMeilleure.Translation
         private const int RegsCount = 32;
         private const int RegsMask  = RegsCount - 1;
 
-        private struct RegisterMask : IEquatable<RegisterMask>
+        private readonly struct RegisterMask : IEquatable<RegisterMask>
         {
             public long IntMask => Mask.GetElement(0);
             public long VecMask => Mask.GetElement(1);

ARMeilleure/Translation/Translator.cs

@@ -293,7 +293,7 @@ namespace ARMeilleure.Translation
             }
         }
 
-        private struct Range
+        private readonly struct Range
         {
             public ulong Start { get; }
             public ulong End { get; }

README.md

@@ -21,6 +21,10 @@
         <img src="https://github.com/Ryujinx/Ryujinx/actions/workflows/release.yml/badge.svg"
             alt="">
     </a>
+    <a href="https://crwd.in/ryujinx">
+        <img src="https://badges.crowdin.net/ryujinx/localized.svg"
+            alt="">
+    </a>
     <a href="https://discord.com/invite/VkQYXAZ">
         <img src="https://img.shields.io/discord/410208534861447168?color=5865F2&label=Ryujinx&logo=discord&logoColor=white"
             alt="Discord">
@@ -48,6 +52,8 @@ See our [Setup & Configuration Guide](https://github.com/Ryujinx/Ryujinx/wiki/Ry
 For our Local Wireless and LAN builds, see our [Multiplayer: Local Play/Local Wireless Guide
 ](https://github.com/Ryujinx/Ryujinx/wiki/Multiplayer-(LDN-Local-Wireless)-Guide).
 
+Avalonia UI comes with translations for various languages. See [Crowdin](https://crwd.in/ryujinx) for more information.
+
 ## Latest build
 
 These builds are compiled automatically for each commit on the master branch. While we strive to ensure optimal stability and performance prior to pushing an update, our automated builds **may be unstable or completely broken.**

Ryujinx.Audio.Backends.SoundIo/Native/SoundIo.cs

@@ -0,0 +1,178 @@
+using Ryujinx.Common.Memory;
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public static partial class SoundIo
+    {
+        private const string LibraryName = "libsoundio";
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public unsafe delegate void OnDeviceChangeNativeDelegate(IntPtr ctx);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public unsafe delegate void OnBackendDisconnectedDelegate(IntPtr ctx, SoundIoError err);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public unsafe delegate void OnEventsSignalDelegate(IntPtr ctx);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public unsafe delegate void EmitRtPrioWarningDelegate();
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public unsafe delegate void JackCallbackDelegate(IntPtr msg);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct SoundIoStruct
+        {
+            public IntPtr UserData;
+            public IntPtr OnDeviceChange;
+            public IntPtr OnBackendDisconnected;
+            public IntPtr OnEventsSignal;
+            public SoundIoBackend CurrentBackend;
+            public IntPtr ApplicationName;
+            public IntPtr EmitRtPrioWarning;
+            public IntPtr JackInfoCallback;
+            public IntPtr JackErrorCallback;
+        }
+
+        public struct SoundIoChannelLayout
+        {
+            public IntPtr Name;
+            public int ChannelCount;
+            public Array24<SoundIoChannelId> Channels;
+
+            public static IntPtr GetDefault(int channelCount)
+            {
+                return soundio_channel_layout_get_default(channelCount);
+            }
+
+            public static unsafe SoundIoChannelLayout GetDefaultValue(int channelCount)
+            {
+                return Unsafe.AsRef<SoundIoChannelLayout>((SoundIoChannelLayout*)GetDefault(channelCount));
+            }
+        }
+
+        public struct SoundIoSampleRateRange
+        {
+            public int Min;
+            public int Max;
+        }
+
+        public struct SoundIoDevice
+        {
+            public IntPtr SoundIo;
+            public IntPtr Id;
+            public IntPtr Name;
+            public SoundIoDeviceAim Aim;
+            public IntPtr Layouts;
+            public int LayoutCount;
+            public SoundIoChannelLayout CurrentLayout;
+            public IntPtr Formats;
+            public int FormatCount;
+            public SoundIoFormat CurrentFormat;
+            public IntPtr SampleRates;
+            public int SampleRateCount;
+            public int SampleRateCurrent;
+            public double SoftwareLatencyMin;
+            public double SoftwareLatencyMax;
+            public double SoftwareLatencyCurrent;
+            public bool IsRaw;
+            public int RefCount;
+            public SoundIoError ProbeError;
+        }
+
+        public struct SoundIoOutStream
+        {
+            public IntPtr Device;
+            public SoundIoFormat Format;
+            public int SampleRate;
+            public SoundIoChannelLayout Layout;
+            public double SoftwareLatency;
+            public float Volume;
+            public IntPtr UserData;
+            public IntPtr WriteCallback;
+            public IntPtr UnderflowCallback;
+            public IntPtr ErrorCallback;
+            public IntPtr Name;
+            public bool NonTerminalHint;
+            public int BytesPerFrame;
+            public int BytesPerSample;
+            public SoundIoError LayoutError;
+        }
+
+        public struct SoundIoChannelArea
+        {
+            public IntPtr Pointer;
+            public int Step;
+        }
+
+        [LibraryImport(LibraryName)]
+        public static partial IntPtr soundio_create();
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_connect(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial void soundio_disconnect(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial void soundio_flush_events(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial int soundio_output_device_count(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial int soundio_default_output_device_index(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial IntPtr soundio_get_output_device(IntPtr ctx, int index);
+
+        [LibraryImport(LibraryName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static partial bool soundio_device_supports_format(IntPtr devCtx, SoundIoFormat format);
+
+        [LibraryImport(LibraryName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static partial bool soundio_device_supports_layout(IntPtr devCtx, IntPtr layout);
+
+        [LibraryImport(LibraryName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static partial bool soundio_device_supports_sample_rate(IntPtr devCtx, int sampleRate);
+
+        [LibraryImport(LibraryName)]
+        public static partial IntPtr soundio_outstream_create(IntPtr devCtx);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_open(IntPtr outStreamCtx);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_start(IntPtr outStreamCtx);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_begin_write(IntPtr outStreamCtx, IntPtr areas, IntPtr frameCount);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_end_write(IntPtr outStreamCtx);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_pause(IntPtr devCtx, [MarshalAs(UnmanagedType.Bool)] bool pause);
+
+        [LibraryImport(LibraryName)]
+        public static partial SoundIoError soundio_outstream_set_volume(IntPtr devCtx, double volume);
+
+        [LibraryImport(LibraryName)]
+        public static partial void soundio_outstream_destroy(IntPtr streamCtx);
+
+        [LibraryImport(LibraryName)]
+        public static partial void soundio_destroy(IntPtr ctx);
+
+        [LibraryImport(LibraryName)]
+        public static partial IntPtr soundio_channel_layout_get_default(int channelCount);
+
+        [LibraryImport(LibraryName)]
+        public static partial IntPtr soundio_strerror(SoundIoError err);
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoBackend.cs

@@ -0,0 +1,13 @@
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public enum SoundIoBackend : int
+    {
+        None = 0,
+        Jack = 1,
+        PulseAudio = 2,
+        Alsa = 3,
+        CoreAudio = 4,
+        Wasapi = 5,
+        Dummy = 6
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoChannelId.cs

@@ -0,0 +1,75 @@
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public enum SoundIoChannelId
+    {
+        Invalid = 0,
+        FrontLeft = 1,
+        FrontRight = 2,
+        FrontCenter = 3,
+        Lfe = 4,
+        BackLeft = 5,
+        BackRight = 6,
+        FrontLeftCenter = 7,
+        FrontRightCenter = 8,
+        BackCenter = 9,
+        SideLeft = 10,
+        SideRight = 11,
+        TopCenter = 12,
+        TopFrontLeft = 13,
+        TopFrontCenter = 14,
+        TopFrontRight = 15,
+        TopBackLeft = 16,
+        TopBackCenter = 17,
+        TopBackRight = 18,
+        BackLeftCenter = 19,
+        BackRightCenter = 20,
+        FrontLeftWide = 21,
+        FrontRightWide = 22,
+        FrontLeftHigh = 23,
+        FrontCenterHigh = 24,
+        FrontRightHigh = 25,
+        TopFrontLeftCenter = 26,
+        TopFrontRightCenter = 27,
+        TopSideLeft = 28,
+        TopSideRight = 29,
+        LeftLfe = 30,
+        RightLfe = 31,
+        Lfe2 = 32,
+        BottomCenter = 33,
+        BottomLeftCenter = 34,
+        BottomRightCenter = 35,
+        MsMid = 36,
+        MsSide = 37,
+        AmbisonicW = 38,
+        AmbisonicX = 39,
+        AmbisonicY = 40,
+        AmbisonicZ = 41,
+        XyX = 42,
+        XyY = 43,
+        HeadphonesLeft = 44,
+        HeadphonesRight = 45,
+        ClickTrack = 46,
+        ForeignLanguage = 47,
+        HearingImpaired = 48,
+        Narration = 49,
+        Haptic = 50,
+        DialogCentricMix = 51,
+        Aux = 52,
+        Aux0 = 53,
+        Aux1 = 54,
+        Aux2 = 55,
+        Aux3 = 56,
+        Aux4 = 57,
+        Aux5 = 58,
+        Aux6 = 59,
+        Aux7 = 60,
+        Aux8 = 61,
+        Aux9 = 62,
+        Aux10 = 63,
+        Aux11 = 64,
+        Aux12 = 65,
+        Aux13 = 66,
+        Aux14 = 67,
+        Aux15 = 68,
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoContext.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Reflection.Metadata;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
+
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public class SoundIoContext : IDisposable
+    {
+        private IntPtr _context;
+        private Action<SoundIoError> _onBackendDisconnect;
+        private OnBackendDisconnectedDelegate _onBackendDisconnectNative;
+
+        public IntPtr Context => _context;
+
+        internal SoundIoContext(IntPtr context)
+        {
+            _context = context;
+            _onBackendDisconnect = null;
+            _onBackendDisconnectNative = null;
+        }
+
+        public SoundIoError Connect() => soundio_connect(_context);
+        public void Disconnect() => soundio_disconnect(_context);
+
+        public void FlushEvents() => soundio_flush_events(_context);
+
+        public int OutputDeviceCount => soundio_output_device_count(_context);
+
+        public int DefaultOutputDeviceIndex => soundio_default_output_device_index(_context);
+
+        public Action<SoundIoError> OnBackendDisconnect
+        {
+            get { return _onBackendDisconnect; }
+            set
+            {
+                _onBackendDisconnect = value;
+
+                if (_onBackendDisconnect == null)
+                {
+                    _onBackendDisconnectNative = null;
+                }
+                else
+                {
+                    _onBackendDisconnectNative = (ctx, err) => _onBackendDisconnect(err);
+                }
+
+                GetContext().OnBackendDisconnected = Marshal.GetFunctionPointerForDelegate(_onBackendDisconnectNative);
+            }
+        }
+
+        private ref SoundIoStruct GetContext()
+        {
+            unsafe
+            {
+                return ref Unsafe.AsRef<SoundIoStruct>((SoundIoStruct*)_context);
+            }
+        }
+
+        public SoundIoDeviceContext GetOutputDevice(int index)
+        {
+            IntPtr deviceContext = soundio_get_output_device(_context, index);
+
+            if (deviceContext == IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return new SoundIoDeviceContext(deviceContext);
+        }
+
+        public static SoundIoContext Create()
+        {
+            IntPtr context = soundio_create();
+
+            if (context == IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return new SoundIoContext(context);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            IntPtr currentContext = Interlocked.Exchange(ref _context, IntPtr.Zero);
+
+            if (currentContext != IntPtr.Zero)
+            {
+                soundio_destroy(currentContext);
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~SoundIoContext()
+        {
+            Dispose(false);
+        }
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoDeviceAim.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public enum SoundIoDeviceAim
+    {
+        SoundIoDeviceAimInput = 0,
+        SoundIoDeviceAimOutput = 1
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoDeviceContext.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
+
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public class SoundIoDeviceContext
+    {
+        private readonly IntPtr _context;
+
+        public IntPtr Context => _context;
+
+        internal SoundIoDeviceContext(IntPtr context)
+        {
+            _context = context;
+        }
+
+        private ref SoundIoDevice GetDeviceContext()
+        {
+            unsafe
+            {
+                return ref Unsafe.AsRef<SoundIoDevice>((SoundIoDevice*)_context);
+            }
+        }
+
+        public bool IsRaw => GetDeviceContext().IsRaw;
+
+        public string Id => Marshal.PtrToStringAnsi(GetDeviceContext().Id);
+
+        public bool SupportsSampleRate(int sampleRate) => soundio_device_supports_sample_rate(_context, sampleRate);
+
+        public bool SupportsFormat(SoundIoFormat format) => soundio_device_supports_format(_context, format);
+
+        public bool SupportsChannelCount(int channelCount) => soundio_device_supports_layout(_context, SoundIoChannelLayout.GetDefault(channelCount));
+
+        public SoundIoOutStreamContext CreateOutStream()
+        {
+            IntPtr context = soundio_outstream_create(_context);
+
+            if (context == IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return new SoundIoOutStreamContext(context);
+        }
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoError.cs

@@ -0,0 +1,22 @@
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public enum SoundIoError
+    {
+        None = 0,
+        NoMem = 1,
+        InitAudioBackend = 2,
+        SystemResources = 3,
+        OpeningDevice = 4,
+        NoSuchDevice = 5,
+        Invalid = 6,
+        BackendUnavailable = 7,
+        Streaming = 8,
+        IncompatibleDevice = 9,
+        NoSuchClient = 10,
+        IncompatibleBackend = 11,
+        BackendDisconnected = 12,
+        Interrupted = 13,
+        Underflow = 14,
+        EncodingString = 15,
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoException.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Runtime.InteropServices;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
+
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    internal class SoundIoException : Exception
+    {
+        internal SoundIoException(SoundIoError error) : base(Marshal.PtrToStringAnsi(soundio_strerror(error))) { }
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoFormat.cs

@@ -0,0 +1,25 @@
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public enum SoundIoFormat
+    {
+        Invalid = 0,
+        S8 = 1,
+        U8 = 2,
+        S16LE = 3,
+        S16BE = 4,
+        U16LE = 5,
+        U16BE = 6,
+        S24LE = 7,
+        S24BE = 8,
+        U24LE = 9,
+        U24BE = 10,
+        S32LE = 11,
+        S32BE = 12,
+        U32LE = 13,
+        U32BE = 14,
+        Float32LE = 15,
+        Float32BE = 16,
+        Float64LE = 17,
+        Float64BE = 18,
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoOutStreamContext.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
+
+namespace Ryujinx.Audio.Backends.SoundIo.Native
+{
+    public class SoundIoOutStreamContext : IDisposable
+    {
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private unsafe delegate void WriteCallbackDelegate(IntPtr ctx, int frameCountMin, int frameCountMax);
+
+        private IntPtr _context;
+        private IntPtr _nameStored;
+        private Action<int, int> _writeCallback;
+        private WriteCallbackDelegate _writeCallbackNative;
+
+        public IntPtr Context => _context;
+
+        internal SoundIoOutStreamContext(IntPtr context)
+        {
+            _context = context;
+            _nameStored = IntPtr.Zero;
+            _writeCallback = null;
+            _writeCallbackNative = null;
+        }
+
+        private ref SoundIoOutStream GetOutContext()
+        {
+            unsafe
+            {
+                return ref Unsafe.AsRef<SoundIoOutStream>((SoundIoOutStream*)_context);
+            }
+        }
+
+        public string Name
+        {
+            get => Marshal.PtrToStringAnsi(GetOutContext().Name);
+            set
+            {
+                var context = GetOutContext();
+
+                if (_nameStored != IntPtr.Zero && context.Name == _nameStored)
+                {
+                    Marshal.FreeHGlobal(_nameStored);
+                }
+
+                _nameStored = Marshal.StringToHGlobalAnsi(value);
+                GetOutContext().Name = _nameStored;
+            }
+        }
+
+        public SoundIoChannelLayout Layout
+        {
+            get => GetOutContext().Layout;
+            set => GetOutContext().Layout = value;
+        }
+
+        public SoundIoFormat Format
+        {
+            get => GetOutContext().Format;
+            set => GetOutContext().Format = value;
+        }
+
+        public int SampleRate
+        {
+            get => GetOutContext().SampleRate;
+            set => GetOutContext().SampleRate = value;
+        }
+
+        public float Volume
+        {
+            get => GetOutContext().Volume;
+            set => GetOutContext().Volume = value;
+        }
+
+        public int BytesPerFrame
+        {
+            get => GetOutContext().BytesPerFrame;
+            set => GetOutContext().BytesPerFrame = value;
+        }
+
+        public int BytesPerSample
+        {
+            get => GetOutContext().BytesPerSample;
+            set => GetOutContext().BytesPerSample = value;
+        }
+
+        public Action<int, int> WriteCallback
+        {
+            get { return _writeCallback; }
+            set
+            {
+                _writeCallback = value;
+
+                if (_writeCallback == null)
+                {
+                    _writeCallbackNative = null;
+                }
+                else
+                {
+                    _writeCallbackNative = (ctx, frameCountMin, frameCountMax) => _writeCallback(frameCountMin, frameCountMax);
+                }
+
+                GetOutContext().WriteCallback = Marshal.GetFunctionPointerForDelegate(_writeCallbackNative);
+            }
+        }
+
+        private static void CheckError(SoundIoError error)
+        {
+            if (error != SoundIoError.None)
+            {
+                throw new SoundIoException(error);
+            }
+        }
+
+        public void Open() => CheckError(soundio_outstream_open(_context));
+
+        public void Start() => CheckError(soundio_outstream_start(_context));
+
+        public void Pause(bool pause) => CheckError(soundio_outstream_pause(_context, pause));
+
+        public void SetVolume(double volume) => CheckError(soundio_outstream_set_volume(_context, volume));
+
+        public Span<SoundIoChannelArea> BeginWrite(ref int frameCount)
+        {
+            IntPtr arenas = default;
+            int nativeFrameCount = frameCount;
+
+            unsafe
+            {
+                var frameCountPtr = &nativeFrameCount;
+                var arenasPtr = &arenas;
+                CheckError(soundio_outstream_begin_write(_context, (IntPtr)arenasPtr, (IntPtr)frameCountPtr));
+
+                frameCount = *frameCountPtr;
+
+                return new Span<SoundIoChannelArea>((void*)arenas, Layout.ChannelCount);
+            }
+        }
+
+        public void EndWrite() => CheckError(soundio_outstream_end_write(_context));
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_context != IntPtr.Zero)
+            {
+                soundio_outstream_destroy(_context);
+                _context = IntPtr.Zero;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~SoundIoOutStreamContext()
+        {
+            Dispose(false);
+        }
+    }
+}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/MarshalExtensions.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public static class MarshalEx
-    {
-        public static double ReadDouble(IntPtr handle, int offset = 0)
-        {
-            return BitConverter.Int64BitsToDouble(Marshal.ReadInt64(handle, offset));
-        }
-
-        public static void WriteDouble(IntPtr handle, double value)
-        {
-            WriteDouble(handle, 0, value);
-        }
-
-        public static void WriteDouble(IntPtr handle, int offset, double value)
-        {
-            Marshal.WriteInt64(handle, offset, BitConverter.DoubleToInt64Bits(value));
-        }
-
-        public static float ReadFloat(IntPtr handle, int offset = 0)
-        {
-            return BitConverter.Int32BitsToSingle(Marshal.ReadInt32(handle, offset));
-        }
-
-        public static void WriteFloat(IntPtr handle, float value)
-        {
-            WriteFloat(handle, 0, value);
-        }
-
-        public static void WriteFloat(IntPtr handle, int offset, float value)
-        {
-            Marshal.WriteInt32(handle, offset, BitConverter.SingleToInt32Bits(value));
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIO.cs

@@ -1,386 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public class SoundIO : IDisposable
-    {
-        Pointer<SoundIo> handle;
-
-        public SoundIO()
-        {
-            handle = Natives.soundio_create();
-        }
-
-        internal SoundIO(Pointer<SoundIo> handle)
-        {
-            this.handle = handle;
-        }
-
-        public void Dispose ()
-        {
-            foreach (var h in allocated_hglobals)
-            {
-                Marshal.FreeHGlobal(h);
-            }
-
-            Natives.soundio_destroy(handle);
-        }
-
-        // Equality (based on handle)
-
-        public override bool Equals(object other)
-        {
-            var d = other as SoundIO;
-
-            return d != null && this.handle == d.handle;
-        }
-
-        public override int GetHashCode()
-        {
-            return (int)(IntPtr)handle;
-        }
-
-        public static bool operator == (SoundIO obj1, SoundIO obj2)
-        {
-            return obj1 is null ? obj2 is null : obj1.Equals(obj2);
-        }
-
-        public static bool operator != (SoundIO obj1, SoundIO obj2)
-        {
-            return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
-        }
-
-        // fields
-
-        // FIXME: this should be taken care in more centralized/decent manner... we don't want to write
-        // this kind of code anywhere we need string marshaling.
-        List<IntPtr> allocated_hglobals = new List<IntPtr>();
-
-        public string ApplicationName {
-            get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, app_name_offset)); }
-            set
-            {
-                unsafe
-                {
-                    var existing = Marshal.ReadIntPtr(handle, app_name_offset);
-                    if (allocated_hglobals.Contains (existing))
-                    {
-                        allocated_hglobals.Remove(existing);
-                        Marshal.FreeHGlobal(existing);
-                    }
-
-                    var ptr = Marshal.StringToHGlobalAnsi(value);
-                    Marshal.WriteIntPtr(handle, app_name_offset, ptr);
-                    allocated_hglobals.Add(ptr);
-                }
-            }
-        }
-
-        static readonly int app_name_offset = (int)Marshal.OffsetOf<SoundIo>("app_name");
-
-        public SoundIOBackend CurrentBackend
-        {
-            get { return (SoundIOBackend)Marshal.ReadInt32(handle, current_backend_offset); }
-        }
-
-        static readonly int current_backend_offset = (int)Marshal.OffsetOf<SoundIo>("current_backend");
-
-        // emit_rtprio_warning
-        public Action EmitRealtimePriorityWarning
-        {
-            get { return emit_rtprio_warning; }
-            set
-            {
-                emit_rtprio_warning = value;
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(on_devices_change);
-
-                Marshal.WriteIntPtr(handle, emit_rtprio_warning_offset, ptr);
-            }
-        }
-
-        static readonly int emit_rtprio_warning_offset = (int)Marshal.OffsetOf<SoundIo>("emit_rtprio_warning");
-
-        Action emit_rtprio_warning;
-
-        // jack_error_callback
-        public Action<string> JackErrorCallback
-        {
-            get { return jack_error_callback; }
-            set
-            {
-                jack_error_callback = value;
-                if (value == null)
-                {
-                    jack_error_callback = null;
-                }
-                else
-                {
-                    jack_error_callback_native = msg => jack_error_callback(msg);
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(jack_error_callback_native);
-                Marshal.WriteIntPtr(handle, jack_error_callback_offset, ptr);
-            }
-        }
-
-        static readonly int jack_error_callback_offset = (int)Marshal.OffsetOf<SoundIo>("jack_error_callback");
-
-        Action<string> jack_error_callback;
-        delegate void jack_error_delegate(string message);
-        jack_error_delegate jack_error_callback_native;
-
-        // jack_info_callback
-        public Action<string> JackInfoCallback
-        {
-            get { return jack_info_callback; }
-            set
-            {
-                jack_info_callback = value;
-                if (value == null)
-                {
-                    jack_info_callback = null;
-                }
-                else
-                {
-                    jack_info_callback_native = msg => jack_info_callback(msg);
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(jack_info_callback_native);
-                Marshal.WriteIntPtr(handle, jack_info_callback_offset, ptr);
-            }
-        }
-
-        static readonly int jack_info_callback_offset = (int)Marshal.OffsetOf<SoundIo>("jack_info_callback");
-
-        Action<string> jack_info_callback;
-        delegate void jack_info_delegate(string message);
-        jack_info_delegate jack_info_callback_native;
-
-        // on_backend_disconnect
-        public Action<int> OnBackendDisconnect
-        {
-            get { return on_backend_disconnect; }
-            set
-            {
-                on_backend_disconnect = value;
-                if (value == null)
-                {
-                    on_backend_disconnect_native = null;
-                }
-                else
-                {
-                    on_backend_disconnect_native = (sio, err) => on_backend_disconnect(err);
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(on_backend_disconnect_native);
-                Marshal.WriteIntPtr(handle, on_backend_disconnect_offset, ptr);
-            }
-        }
-
-        static readonly int on_backend_disconnect_offset = (int)Marshal.OffsetOf<SoundIo>("on_backend_disconnect");
-
-        Action<int> on_backend_disconnect;
-        delegate void on_backend_disconnect_delegate(IntPtr handle, int errorCode);
-        on_backend_disconnect_delegate on_backend_disconnect_native;
-
-        // on_devices_change
-        public Action OnDevicesChange
-        {
-            get { return on_devices_change; }
-            set
-            {
-                on_devices_change = value;
-                if (value == null)
-                {
-                    on_devices_change_native = null;
-                }
-                else
-                {
-                    on_devices_change_native = sio => on_devices_change();
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(on_devices_change_native);
-                Marshal.WriteIntPtr(handle, on_devices_change_offset, ptr);
-            }
-        }
-
-        static readonly int on_devices_change_offset = (int)Marshal.OffsetOf<SoundIo>("on_devices_change");
-
-        Action on_devices_change;
-        delegate void on_devices_change_delegate(IntPtr handle);
-        on_devices_change_delegate on_devices_change_native;
-
-        // on_events_signal
-        public Action OnEventsSignal
-        {
-            get { return on_events_signal; }
-            set
-            {
-                on_events_signal = value;
-                if (value == null)
-                {
-                    on_events_signal_native = null;
-                }
-                else
-                {
-                    on_events_signal_native = sio => on_events_signal();
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(on_events_signal_native);
-                Marshal.WriteIntPtr(handle, on_events_signal_offset, ptr);
-            }
-        }
-
-        static readonly int on_events_signal_offset = (int)Marshal.OffsetOf<SoundIo>("on_events_signal");
-
-        Action on_events_signal;
-        delegate void on_events_signal_delegate(IntPtr handle);
-        on_events_signal_delegate on_events_signal_native;
-
-
-        // functions
-
-        public int BackendCount
-        {
-            get { return Natives.soundio_backend_count(handle); }
-        }
-
-        public int InputDeviceCount
-        {
-            get { return Natives.soundio_input_device_count(handle); }
-        }
-
-        public int OutputDeviceCount
-        {
-            get { return Natives.soundio_output_device_count(handle); }
-        }
-
-        public int DefaultInputDeviceIndex
-        {
-            get { return Natives.soundio_default_input_device_index(handle); }
-        }
-
-        public int DefaultOutputDeviceIndex
-        {
-            get { return Natives.soundio_default_output_device_index(handle); }
-        }
-
-        public SoundIOBackend GetBackend(int index)
-        {
-            return (SoundIOBackend)Natives.soundio_get_backend(handle, index);
-        }
-
-        public SoundIODevice GetInputDevice(int index)
-        {
-            return new SoundIODevice(Natives.soundio_get_input_device(handle, index));
-        }
-
-        public SoundIODevice GetOutputDevice(int index)
-        {
-            return new SoundIODevice(Natives.soundio_get_output_device(handle, index));
-        }
-
-        public void Connect()
-        {
-            var ret = (SoundIoError)Natives.soundio_connect(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void ConnectBackend(SoundIOBackend backend)
-        {
-            var ret = (SoundIoError)Natives.soundio_connect_backend(handle, (SoundIoBackend)backend);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void Disconnect()
-        {
-            Natives.soundio_disconnect(handle);
-        }
-
-        public void FlushEvents()
-        {
-            Natives.soundio_flush_events(handle);
-        }
-
-        public void WaitEvents()
-        {
-            Natives.soundio_wait_events(handle);
-        }
-
-        public void Wakeup()
-        {
-            Natives.soundio_wakeup(handle);
-        }
-
-        public void ForceDeviceScan()
-        {
-            Natives.soundio_force_device_scan(handle);
-        }
-
-        public SoundIORingBuffer CreateRingBuffer(int capacity)
-        {
-            return new SoundIORingBuffer(Natives.soundio_ring_buffer_create(handle, capacity));
-        }
-
-        // static methods
-
-        public static string VersionString
-        {
-            get { return Marshal.PtrToStringAnsi(Natives.soundio_version_string()); }
-        }
-
-        public static int VersionMajor
-        {
-            get { return Natives.soundio_version_major(); }
-        }
-
-        public static int VersionMinor
-        {
-            get { return Natives.soundio_version_minor(); }
-        }
-
-        public static int VersionPatch
-        {
-            get { return Natives.soundio_version_patch(); }
-        }
-
-        public static string GetBackendName(SoundIOBackend backend)
-        {
-            return Marshal.PtrToStringAnsi(Natives.soundio_backend_name((SoundIoBackend)backend));
-        }
-
-        public static bool HaveBackend(SoundIOBackend backend)
-        {
-            return Natives.soundio_have_backend((SoundIoBackend)backend);
-        }
-
-        public static int GetBytesPerSample(SoundIOFormat format)
-        {
-            return Natives.soundio_get_bytes_per_sample((SoundIoFormat)format);
-        }
-
-        public static int GetBytesPerFrame(SoundIOFormat format, int channelCount)
-        {
-            return Natives.soundio_get_bytes_per_frame((SoundIoFormat)format, channelCount);
-        }
-
-        public static int GetBytesPerSecond(SoundIOFormat format, int channelCount, int sampleRate)
-        {
-            return Natives.soundio_get_bytes_per_second((SoundIoFormat)format, channelCount, sampleRate);
-        }
-
-        public static string GetSoundFormatName(SoundIOFormat format)
-        {
-            return Marshal.PtrToStringAnsi(Natives.soundio_format_string((SoundIoFormat)format));
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOBackend.cs

@@ -1,13 +0,0 @@
-namespace SoundIOSharp
-{
-    public enum SoundIOBackend
-    {
-        None,
-        Jack,
-        PulseAudio,
-        Alsa,
-        CoreAudio,
-        Wasapi,
-        Dummy
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOChannelArea.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public struct SoundIOChannelArea
-    {
-        internal SoundIOChannelArea(Pointer<SoundIoChannelArea> handle)
-        {
-            this.handle = handle;
-        }
-
-        Pointer<SoundIoChannelArea> handle;
-
-        public IntPtr Pointer
-        {
-            get { return Marshal.ReadIntPtr(handle, ptr_offset); }
-            set { Marshal.WriteIntPtr(handle, ptr_offset, value); }
-        }
-
-        static readonly int ptr_offset = (int)Marshal.OffsetOf<SoundIoChannelArea>("ptr");
-
-        public int Step
-        {
-            get { return Marshal.ReadInt32(handle, step_offset); }
-        }
-
-        static readonly int step_offset = (int)Marshal.OffsetOf<SoundIoChannelArea>("step");
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOChannelAreas.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public struct SoundIOChannelAreas
-    {
-        static readonly int native_size = Marshal.SizeOf<SoundIoChannelArea>();
-
-        internal SoundIOChannelAreas(IntPtr head, int channelCount, int frameCount)
-        {
-            this.head          = head;
-            this.channel_count = channelCount;
-            this.frame_count   = frameCount;
-        }
-
-        IntPtr head;
-        int    channel_count;
-        int    frame_count;
-
-        public bool IsEmpty
-        {
-            get { return head == IntPtr.Zero; }
-        }
-
-        public SoundIOChannelArea GetArea(int channel)
-        {
-            return new SoundIOChannelArea(head + native_size * channel);
-        }
-
-        public int ChannelCount => channel_count;
-        public int FrameCount => frame_count;
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOChannelId.cs

@@ -1,75 +0,0 @@
-namespace SoundIOSharp
-{
-    public enum SoundIOChannelId
-    {
-        Invalid,
-        FrontLeft,
-        FrontRight,
-        FrontCenter,
-        Lfe,
-        BackLeft,
-        BackRight,
-        FrontLeftCenter,
-        FrontRightCenter,
-        BackCenter,
-        SideLeft,
-        SideRight,
-        TopCenter,
-        TopFrontLeft,
-        TopFrontCenter,
-        TopFrontRight,
-        TopBackLeft,
-        TopBackCenter,
-        TopBackRight,
-        BackLeftCenter,
-        BackRightCenter,
-        FrontLeftWide,
-        FrontRightWide,
-        FrontLeftHigh,
-        FrontCenterHigh,
-        FrontRightHigh,
-        TopFrontLeftCenter,
-        TopFrontRightCenter,
-        TopSideLeft,
-        TopSideRight,
-        LeftLfe,
-        RightLfe,
-        Lfe2,
-        BottomCenter,
-        BottomLeftCenter,
-        BottomRightCenter,
-        MsMid,
-        MsSide,
-        AmbisonicW,
-        AmbisonicX,
-        AmbisonicY,
-        AmbisonicZ,
-        XyX,
-        XyY,
-        HeadphonesLeft,
-        HeadphonesRight,
-        ClickTrack,
-        ForeignLanguage,
-        HearingImpaired,
-        Narration,
-        Haptic,
-        DialogCentricMix,
-        Aux,
-        Aux0,
-        Aux1,
-        Aux2,
-        Aux3,
-        Aux4,
-        Aux5,
-        Aux6,
-        Aux7,
-        Aux8,
-        Aux9,
-        Aux10,
-        Aux11,
-        Aux12,
-        Aux13,
-        Aux14,
-        Aux15
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOChannelLayout.cs

@@ -1,116 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public struct SoundIOChannelLayout
-    {
-        public static int BuiltInCount
-        {
-            get { return Natives.soundio_channel_layout_builtin_count(); }
-        }
-
-        public static SoundIOChannelLayout GetBuiltIn(int index)
-        {
-            return new SoundIOChannelLayout(Natives.soundio_channel_layout_get_builtin(index));
-        }
-
-        public static SoundIOChannelLayout GetDefault(int channelCount)
-        {
-            var handle = Natives.soundio_channel_layout_get_default(channelCount);
-
-            return new SoundIOChannelLayout (handle);
-        }
-
-        public static SoundIOChannelId ParseChannelId(string name)
-        {
-            var ptr = Marshal.StringToHGlobalAnsi(name);
-
-            try 
-            {
-                return (SoundIOChannelId)Natives.soundio_parse_channel_id(ptr, name.Length);
-            }
-            finally
-            {
-                Marshal.FreeHGlobal(ptr);
-            }
-        }
-
-        // instance members
-
-        internal SoundIOChannelLayout(Pointer<SoundIoChannelLayout> handle)
-        {
-            this.handle = handle;
-        }
-
-        readonly Pointer<SoundIoChannelLayout> handle;
-
-        public bool IsNull
-        {
-            get { return handle.Handle == IntPtr.Zero; }
-        }
-
-        internal IntPtr Handle
-        {
-            get { return handle; }
-        }
-
-        public int ChannelCount
-        {
-            get { return IsNull ? 0 : Marshal.ReadInt32((IntPtr)handle + channel_count_offset); }
-        }
-
-        static readonly int channel_count_offset = (int)Marshal.OffsetOf<SoundIoChannelLayout>("channel_count");
-
-        public string Name
-        {
-            get { return IsNull ? null : Marshal.PtrToStringAnsi(Marshal.ReadIntPtr((IntPtr)handle + name_offset)); }
-        }
-
-        static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoChannelLayout>("name");
-
-        public IEnumerable<SoundIOChannelId> Channels
-        {
-            get
-            {
-                if (IsNull) yield break;
-
-                for (int i = 0; i < 24; i++)
-                {
-                    yield return (SoundIOChannelId)Marshal.ReadInt32((IntPtr)handle + channels_offset + sizeof(SoundIoChannelId) * i);
-                }
-            }
-        }
-
-        static readonly int channels_offset = (int)Marshal.OffsetOf<SoundIoChannelLayout>("channels");
-
-        public override bool Equals(object other)
-        {
-            if (!(other is SoundIOChannelLayout)) return false;
-
-            var s = (SoundIOChannelLayout) other;
-
-            return handle == s.handle || Natives.soundio_channel_layout_equal(handle, s.handle);
-        }
-
-        public override int GetHashCode()
-        {
-            return handle.GetHashCode();
-        }
-
-        public string DetectBuiltInName()
-        {
-            if (IsNull) throw new InvalidOperationException();
-
-            return Natives.soundio_channel_layout_detect_builtin(handle) ? Name : null;
-        }
-
-        public int FindChannel(SoundIOChannelId channel)
-        {
-            if (IsNull) throw new InvalidOperationException();
-
-            return Natives.soundio_channel_layout_find_channel(handle, (SoundIoChannelId)channel);
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIODevice.cs

@@ -1,267 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public class SoundIODevice
-    {
-        public static SoundIOChannelLayout BestMatchingChannelLayout(SoundIODevice device1, SoundIODevice device2)
-        {
-            var ptr1 = Marshal.ReadIntPtr(device1.handle, layouts_offset);
-            var ptr2 = Marshal.ReadIntPtr(device2.handle, layouts_offset);
-
-            return new SoundIOChannelLayout(Natives.soundio_best_matching_channel_layout(ptr1, device1.LayoutCount, ptr2, device2.LayoutCount));
-        }
-
-        internal SoundIODevice(Pointer<SoundIoDevice> handle)
-        {
-            this.handle = handle;
-        }
-
-        readonly Pointer<SoundIoDevice> handle;
-
-        // Equality (based on handle and native func)
-
-        public override bool Equals(object other)
-        {
-            var d = other as SoundIODevice;
-
-            return d != null && (this.handle == d.handle || Natives.soundio_device_equal (this.handle, d.handle));
-        }
-
-        public override int GetHashCode()
-        {
-            return (int)(IntPtr)handle;
-        }
-
-        public static bool operator == (SoundIODevice obj1, SoundIODevice obj2)
-        {
-            return obj1 is null ? obj2 is null : obj1.Equals(obj2);
-        }
-
-        public static bool operator != (SoundIODevice obj1, SoundIODevice obj2)
-        {
-            return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
-        }
-
-        // fields
-
-        public SoundIODeviceAim Aim
-        {
-            get { return (SoundIODeviceAim)Marshal.ReadInt32(handle, aim_offset); }
-        }
-
-        static readonly int aim_offset = (int)Marshal.OffsetOf<SoundIoDevice>("aim");
-
-        public SoundIOFormat CurrentFormat
-        {
-            get { return (SoundIOFormat)Marshal.ReadInt32(handle, current_format_offset); }
-        }
-
-        static readonly int current_format_offset = (int)Marshal.OffsetOf<SoundIoDevice>("current_format");
-
-        public SoundIOChannelLayout CurrentLayout
-        {
-            get { return new SoundIOChannelLayout((IntPtr)handle + current_layout_offset); }
-        }
-
-        static readonly int current_layout_offset = (int)Marshal.OffsetOf<SoundIoDevice>("current_layout");
-
-        public int FormatCount
-        {
-            get { return Marshal.ReadInt32(handle, format_count_offset); }
-        }
-
-        static readonly int format_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("format_count");
-
-        public IEnumerable<SoundIOFormat> Formats
-        {
-            get
-            {
-                var ptr = Marshal.ReadIntPtr(handle, formats_offset);
-
-                for (int i = 0; i < FormatCount; i++)
-                {
-                    yield return (SoundIOFormat)Marshal.ReadInt32(ptr, i);
-                }
-            }
-        }
-
-        static readonly int formats_offset = (int)Marshal.OffsetOf<SoundIoDevice>("formats");
-
-        public string Id
-        {
-            get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, id_offset)); }
-        }
-
-        static readonly int id_offset = (int)Marshal.OffsetOf<SoundIoDevice>("id");
-
-        public bool IsRaw
-        {
-            get { return Marshal.ReadInt32(handle, is_raw_offset) != 0; }
-        }
-
-        static readonly int is_raw_offset = (int)Marshal.OffsetOf<SoundIoDevice>("is_raw");
-
-        public int LayoutCount
-        {
-            get { return Marshal.ReadInt32(handle, layout_count_offset); }
-        }
-
-        static readonly int layout_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("layout_count");
-
-        public IEnumerable<SoundIOChannelLayout> Layouts
-        {
-            get
-            {
-                var ptr = Marshal.ReadIntPtr (handle, layouts_offset);
-
-                for (int i = 0; i < LayoutCount; i++)
-                {
-                    yield return new SoundIOChannelLayout(ptr + i * Marshal.SizeOf<SoundIoChannelLayout>());
-                }
-            }
-        }
-
-        static readonly int layouts_offset = (int)Marshal.OffsetOf<SoundIoDevice>("layouts");
-
-        public string Name
-        {
-            get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, name_offset)); }
-        }
-
-        static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoDevice>("name");
-
-        public int ProbeError
-        {
-            get { return Marshal.ReadInt32(handle, probe_error_offset); }
-        }
-
-        static readonly int probe_error_offset = (int)Marshal.OffsetOf<SoundIoDevice>("probe_error");
-
-        public int ReferenceCount
-        {
-            get { return Marshal.ReadInt32(handle, ref_count_offset); }
-        }
-
-        static readonly int ref_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("ref_count");
-
-        public int SampleRateCount
-        {
-            get { return Marshal.ReadInt32(handle, sample_rate_count_offset); }
-        }
-
-        static readonly int sample_rate_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("sample_rate_count");
-
-        public IEnumerable<SoundIOSampleRateRange> SampleRates
-        {
-            get
-            {
-                var ptr = Marshal.ReadIntPtr(handle, sample_rates_offset);
-
-                for (int i = 0; i < SampleRateCount; i++)
-                {
-                    yield return new SoundIOSampleRateRange(Marshal.ReadInt32(ptr, i * 2), Marshal.ReadInt32(ptr, i * 2 + 1));
-                }
-            }
-        }
-
-        static readonly int sample_rates_offset = (int)Marshal.OffsetOf<SoundIoDevice>("sample_rates");
-
-        public double SoftwareLatencyCurrent
-        {
-            get { return MarshalEx.ReadDouble(handle, software_latency_current_offset); }
-            set { MarshalEx.WriteDouble(handle, software_latency_current_offset, value); }
-        }
-
-        static readonly int software_latency_current_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_current");
-
-        public double SoftwareLatencyMin
-        {
-            get { return MarshalEx.ReadDouble(handle, software_latency_min_offset); }
-            set { MarshalEx.WriteDouble(handle, software_latency_min_offset, value); }
-        }
-
-        static readonly int software_latency_min_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_min");
-
-        public double SoftwareLatencyMax
-        {
-            get { return MarshalEx.ReadDouble(handle, software_latency_max_offset); }
-            set { MarshalEx.WriteDouble(handle, software_latency_max_offset, value); }
-        }
-
-        static readonly int software_latency_max_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_max");
-
-        public SoundIO SoundIO
-        {
-            get { return new SoundIO(Marshal.ReadIntPtr(handle, soundio_offset)); }
-        }
-
-        static readonly int soundio_offset = (int)Marshal.OffsetOf<SoundIoDevice>("soundio");
-
-        // functions
-
-        public void AddReference()
-        {
-            Natives.soundio_device_ref(handle);
-        }
-
-        public void RemoveReference()
-        {
-            Natives.soundio_device_unref(handle);
-        }
-
-        public void SortDeviceChannelLayouts()
-        {
-            Natives.soundio_device_sort_channel_layouts(handle);
-        }
-
-        public static readonly SoundIOFormat S16NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.S16LE     : SoundIOFormat.S16BE;
-        public static readonly SoundIOFormat U16NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.U16LE     : SoundIOFormat.U16BE;
-        public static readonly SoundIOFormat S24NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.S24LE     : SoundIOFormat.S24BE;
-        public static readonly SoundIOFormat U24NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.U24LE     : SoundIOFormat.U24BE;
-        public static readonly SoundIOFormat S32NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.S32LE     : SoundIOFormat.S32BE;
-        public static readonly SoundIOFormat U32NE     =  BitConverter.IsLittleEndian ? SoundIOFormat.U32LE     : SoundIOFormat.U32BE;
-        public static readonly SoundIOFormat Float32NE =  BitConverter.IsLittleEndian ? SoundIOFormat.Float32LE : SoundIOFormat.Float32BE;
-        public static readonly SoundIOFormat Float64NE =  BitConverter.IsLittleEndian ? SoundIOFormat.Float64LE : SoundIOFormat.Float64BE;
-        public static readonly SoundIOFormat S16FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.S16LE     : SoundIOFormat.S16BE;
-        public static readonly SoundIOFormat U16FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.U16LE     : SoundIOFormat.U16BE;
-        public static readonly SoundIOFormat S24FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.S24LE     : SoundIOFormat.S24BE;
-        public static readonly SoundIOFormat U24FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.U24LE     : SoundIOFormat.U24BE;
-        public static readonly SoundIOFormat S32FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.S32LE     : SoundIOFormat.S32BE;
-        public static readonly SoundIOFormat U32FE     = !BitConverter.IsLittleEndian ? SoundIOFormat.U32LE     : SoundIOFormat.U32BE;
-        public static readonly SoundIOFormat Float32FE = !BitConverter.IsLittleEndian ? SoundIOFormat.Float32LE : SoundIOFormat.Float32BE;
-        public static readonly SoundIOFormat Float64FE = !BitConverter.IsLittleEndian ? SoundIOFormat.Float64LE : SoundIOFormat.Float64BE;
-
-        public bool SupportsFormat(SoundIOFormat format)
-        {
-            return Natives.soundio_device_supports_format(handle, (SoundIoFormat)format);
-        }
-
-        public bool SupportsSampleRate(int sampleRate)
-        {
-            return Natives.soundio_device_supports_sample_rate(handle, sampleRate);
-        }
-
-        public bool SupportsChannelCount(int channelCount)
-        {
-            return Natives.soundio_device_supports_layout(handle, SoundIOChannelLayout.GetDefault(channelCount).Handle);
-        }
-
-        public int GetNearestSampleRate(int sampleRate)
-        {
-            return Natives.soundio_device_nearest_sample_rate(handle, sampleRate);
-        }
-
-        public SoundIOInStream CreateInStream()
-        {
-            return new SoundIOInStream(Natives.soundio_instream_create(handle));
-        }
-
-        public SoundIOOutStream CreateOutStream()
-        {
-            return new SoundIOOutStream(Natives.soundio_outstream_create(handle));
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIODeviceAim.cs

@@ -1,8 +0,0 @@
-namespace SoundIOSharp
-{
-    public enum SoundIODeviceAim // soundio.h (228, 6)
-    {
-        Input,
-        Output
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOException.cs

@@ -1,10 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public class SoundIOException : Exception
-    {
-        internal SoundIOException(SoundIoError errorCode) : base (Marshal.PtrToStringAnsi(Natives.soundio_strerror((int) errorCode))) { }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOFormat.cs

@@ -1,25 +0,0 @@
-namespace SoundIOSharp
-{
-    public enum SoundIOFormat
-	{
-		Invalid,
-		S8,
-		U8,
-		S16LE,
-		S16BE,
-		U16LE,
-		U16BE,
-		S24LE,
-		S24BE,
-		U24LE,
-		U24BE,
-		S32LE,
-		S32BE,
-		U32LE,
-		U32BE,
-		Float32LE,
-		Float32BE,
-		Float64LE,
-		Float64BE
-	}
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOInStream.cs

@@ -1,293 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public class SoundIOInStream : IDisposable
-    {
-        internal SoundIOInStream(Pointer<SoundIoInStream> handle)
-        {
-            this.handle = handle;
-        }
-
-        Pointer<SoundIoInStream> handle;
-
-        public void Dispose()
-        {
-            Natives.soundio_instream_destroy(handle);
-        }
-
-        // Equality (based on handle)
-
-        public override bool Equals(object other)
-        {
-            var d = other as SoundIOInStream;
-
-            return d != null && (this.handle == d.handle);
-        }
-
-        public override int GetHashCode()
-        {
-            return (int)(IntPtr)handle;
-        }
-
-        public static bool operator == (SoundIOInStream obj1, SoundIOInStream obj2)
-        {
-            return obj1 is null ? obj2 is null : obj1.Equals(obj2);
-        }
-
-        public static bool operator != (SoundIOInStream obj1, SoundIOInStream obj2)
-        {
-            return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
-        }
-
-        // fields
-
-        public SoundIODevice Device
-        {
-            get { return new SoundIODevice(Marshal.ReadIntPtr(handle, device_offset)); }
-        }
-
-        static readonly int device_offset = (int)Marshal.OffsetOf<SoundIoInStream>("device");
-
-        public SoundIOFormat Format
-        {
-            get { return (SoundIOFormat)Marshal.ReadInt32(handle, format_offset); }
-            set { Marshal.WriteInt32(handle, format_offset, (int) value); }
-        }
-
-        static readonly int format_offset = (int)Marshal.OffsetOf<SoundIoInStream>("format");
-
-        public int SampleRate
-        {
-            get { return Marshal.ReadInt32(handle, sample_rate_offset); }
-            set { Marshal.WriteInt32(handle, sample_rate_offset, value); }
-        }
-
-        static readonly int sample_rate_offset = (int)Marshal.OffsetOf<SoundIoInStream>("sample_rate");
-
-        public SoundIOChannelLayout Layout
-        {
-            get { return new SoundIOChannelLayout ((IntPtr) handle + layout_offset); }
-            set 
-            {
-                unsafe
-                {
-                    Buffer.MemoryCopy((void*)((IntPtr)handle + layout_offset), (void*)value.Handle, Marshal.SizeOf<SoundIoChannelLayout>(), Marshal.SizeOf<SoundIoChannelLayout>());
-                }
-            }
-        }
-
-        static readonly int layout_offset = (int)Marshal.OffsetOf<SoundIoInStream>("layout");
-
-        public double SoftwareLatency
-        {
-            get { return MarshalEx.ReadDouble(handle, software_latency_offset); }
-            set { MarshalEx.WriteDouble(handle, software_latency_offset, value); }
-        }
-
-        static readonly int software_latency_offset = (int)Marshal.OffsetOf<SoundIoInStream>("software_latency");
-
-        // error_callback
-        public Action ErrorCallback
-        {
-            get { return error_callback; }
-            set
-            {
-                error_callback = value;
-                error_callback_native = _ => error_callback();
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(error_callback_native);
-
-                Marshal.WriteIntPtr(handle, error_callback_offset, ptr);
-            }
-        }
-
-        static readonly int error_callback_offset = (int)Marshal.OffsetOf<SoundIoInStream>("error_callback");
-
-        Action error_callback;
-        delegate void error_callback_delegate(IntPtr handle);
-        error_callback_delegate error_callback_native;
-
-        // read_callback
-        public Action<int,int> ReadCallback
-        {
-            get { return read_callback; }
-            set
-            {
-                read_callback = value;
-                read_callback_native = (_, minFrameCount, maxFrameCount) => read_callback(minFrameCount, maxFrameCount);
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(read_callback_native);
-
-                Marshal.WriteIntPtr(handle, read_callback_offset, ptr);
-            }
-        }
-
-        static readonly int read_callback_offset = (int)Marshal.OffsetOf<SoundIoInStream>("read_callback");
-
-        Action<int, int> read_callback;
-        delegate void read_callback_delegate(IntPtr handle, int min, int max);
-        read_callback_delegate read_callback_native;
-
-        // overflow_callback
-        public Action OverflowCallback
-        {
-            get { return overflow_callback; }
-            set
-            {
-                overflow_callback = value;
-                overflow_callback_native = _ => overflow_callback();
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(overflow_callback_native);
-
-                Marshal.WriteIntPtr(handle, overflow_callback_offset, ptr);
-            }
-        }
-        static readonly int overflow_callback_offset = (int)Marshal.OffsetOf<SoundIoInStream>("overflow_callback");
-
-        Action overflow_callback;
-        delegate void overflow_callback_delegate(IntPtr handle);
-        overflow_callback_delegate overflow_callback_native;
-
-        // FIXME: this should be taken care in more centralized/decent manner... we don't want to write
-        // this kind of code anywhere we need string marshaling.
-        List<IntPtr> allocated_hglobals = new List<IntPtr>();
-
-        public string Name
-        {
-            get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, name_offset)); }
-            set
-            {
-                unsafe
-                {
-                    var existing = Marshal.ReadIntPtr(handle, name_offset);
-                    if (allocated_hglobals.Contains(existing))
-                    {
-                        allocated_hglobals.Remove(existing);
-                        Marshal.FreeHGlobal(existing);
-                    }
-
-                    var ptr = Marshal.StringToHGlobalAnsi(value);
-                    Marshal.WriteIntPtr(handle, name_offset, ptr);
-                    allocated_hglobals.Add(ptr);
-                }
-            }
-        }
-
-        static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoInStream>("name");
-
-        public bool NonTerminalHint
-        {
-            get { return Marshal.ReadInt32(handle, non_terminal_hint_offset) != 0; }
-        }
-
-        static readonly int non_terminal_hint_offset = (int)Marshal.OffsetOf<SoundIoInStream>("non_terminal_hint");
-
-        public int BytesPerFrame
-        {
-            get { return Marshal.ReadInt32(handle, bytes_per_frame_offset); }
-        }
-
-        static readonly int bytes_per_frame_offset = (int)Marshal.OffsetOf<SoundIoInStream>("bytes_per_frame");
-
-        public int BytesPerSample
-        {
-            get { return Marshal.ReadInt32(handle, bytes_per_sample_offset); }
-        }
-
-        static readonly int bytes_per_sample_offset = (int)Marshal.OffsetOf<SoundIoInStream>("bytes_per_sample");
-
-        public string LayoutErrorMessage
-        {
-            get 
-            {
-                var code = (SoundIoError)Marshal.ReadInt32(handle, layout_error_offset);
-
-                return code == SoundIoError.SoundIoErrorNone ? null : Marshal.PtrToStringAnsi(Natives.soundio_strerror((int)code));
-            }
-        }
-
-        static readonly int layout_error_offset = (int)Marshal.OffsetOf<SoundIoInStream>("layout_error");
-
-        // functions
-
-        public void Open()
-        {
-            var ret = (SoundIoError)Natives.soundio_instream_open(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void Start()
-        {
-            var ret = (SoundIoError)Natives.soundio_instream_start(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public SoundIOChannelAreas BeginRead(ref int frameCount)
-        {
-            IntPtr ptrs             = default;
-            int    nativeFrameCount = frameCount;
-
-            unsafe
-            {
-                var frameCountPtr = &nativeFrameCount;
-                var ptrptr        = &ptrs;
-                var ret           = (SoundIoError)Natives.soundio_instream_begin_read(handle, (IntPtr)ptrptr, (IntPtr)frameCountPtr);
-
-                frameCount = *frameCountPtr;
-
-                if (ret != SoundIoError.SoundIoErrorNone)
-                {
-                    throw new SoundIOException(ret);
-                }
-
-                return new SoundIOChannelAreas(ptrs, Layout.ChannelCount, frameCount);
-            }
-        }
-
-        public void EndRead()
-        {
-            var ret = (SoundIoError)Natives.soundio_instream_end_read(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void Pause(bool pause)
-        {
-            var ret = (SoundIoError)Natives.soundio_instream_pause(handle, pause);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public double GetLatency()
-        {
-            unsafe
-            {
-                double* dptr = null;
-                IntPtr  p    = new IntPtr(dptr);
-
-                var ret = (SoundIoError)Natives.soundio_instream_get_latency(handle, p);
-                if (ret != SoundIoError.SoundIoErrorNone)
-                {
-                    throw new SoundIOException(ret);
-                }
-
-                dptr = (double*)p;
-
-                return *dptr;
-            }
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOOutStream.cs

@@ -1,331 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace SoundIOSharp
-{
-    public class SoundIOOutStream : IDisposable
-    {
-        internal SoundIOOutStream (Pointer<SoundIoOutStream> handle)
-        {
-            this.handle = handle;
-        }
-
-        Pointer<SoundIoOutStream> handle;
-
-        public void Dispose ()
-        {
-            Natives.soundio_outstream_destroy (handle);
-        }
-        // Equality (based on handle)
-
-        public override bool Equals (object other)
-        {
-            var d = other as SoundIOOutStream;
-
-            return d != null && (this.handle == d.handle);
-        }
-
-        public override int GetHashCode ()
-        {
-            return (int)(IntPtr)handle;
-        }
-
-        public static bool operator == (SoundIOOutStream obj1, SoundIOOutStream obj2)
-        {
-            return obj1 is null ? obj2 is null : obj1.Equals(obj2);
-        }
-
-        public static bool operator != (SoundIOOutStream obj1, SoundIOOutStream obj2)
-        {
-            return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
-        }
-
-        // fields
-
-        public SoundIODevice Device
-        {
-            get { return new SoundIODevice(Marshal.ReadIntPtr(handle, device_offset)); }
-        }
-
-        static readonly int device_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("device");
-
-        public SoundIOFormat Format
-        {
-            get { return (SoundIOFormat) Marshal.ReadInt32(handle, format_offset); }
-            set { Marshal.WriteInt32(handle, format_offset, (int) value); }
-        }
-
-        static readonly int format_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("format");
-
-        public int SampleRate
-        {
-            get { return Marshal.ReadInt32(handle, sample_rate_offset); }
-            set { Marshal.WriteInt32(handle, sample_rate_offset, value); }
-        }
-
-        static readonly int sample_rate_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("sample_rate");
-
-        public SoundIOChannelLayout Layout
-        {
-            get { unsafe { return new SoundIOChannelLayout((IntPtr) (void*)((IntPtr)handle + layout_offset)); } }
-            set
-            {
-                unsafe
-                {
-                    Buffer.MemoryCopy((void*)value.Handle, (void*)((IntPtr)handle + layout_offset), Marshal.SizeOf<SoundIoChannelLayout>(), Marshal.SizeOf<SoundIoChannelLayout>());
-                }
-            }
-        }
-        static readonly int layout_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("layout");
-
-        public double SoftwareLatency
-        {
-            get { return MarshalEx.ReadDouble (handle, software_latency_offset); }
-            set { MarshalEx.WriteDouble (handle, software_latency_offset, value); }
-        }
-
-        static readonly int software_latency_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("software_latency");
-
-        public float Volume
-        {
-            get { return MarshalEx.ReadFloat(handle, volume_offset); }
-            set { MarshalEx.WriteFloat(handle, volume_offset, value); }
-        }
-
-        static readonly int volume_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("volume");
-
-        // error_callback
-        public Action ErrorCallback
-        {
-            get { return error_callback; }
-            set
-            {
-                error_callback = value;
-                if (value == null)
-                {
-                    error_callback_native = null;
-                }
-                else
-                {
-                    error_callback_native = stream => error_callback();
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate(error_callback_native);
-                Marshal.WriteIntPtr(handle, error_callback_offset, ptr);
-            }
-        }
-
-        static readonly int error_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("error_callback");
-
-        Action error_callback;
-        delegate void error_callback_delegate (IntPtr handle);
-        error_callback_delegate error_callback_native;
-
-        // write_callback
-        public Action<int, int> WriteCallback
-        {
-            get { return write_callback; }
-            set
-            {
-                write_callback = value;
-                if (value == null)
-                {
-                    write_callback_native = null;
-                }
-                else
-                {
-                    write_callback_native = (h, frame_count_min, frame_count_max) => write_callback(frame_count_min, frame_count_max);
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate (write_callback_native);
-                Marshal.WriteIntPtr (handle, write_callback_offset, ptr);
-            }
-        }
-
-        static readonly int write_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("write_callback");
-
-        Action<int, int> write_callback;
-        delegate void write_callback_delegate(IntPtr handle, int min, int max);
-        write_callback_delegate write_callback_native;
-
-        // underflow_callback
-        public Action UnderflowCallback
-        {
-            get { return underflow_callback; }
-            set
-            {
-                underflow_callback = value;
-                if (value == null)
-                {
-                    underflow_callback_native = null;
-                }
-                else
-                {
-                    underflow_callback_native = h => underflow_callback();
-                }
-
-                var ptr = Marshal.GetFunctionPointerForDelegate (underflow_callback_native);
-                Marshal.WriteIntPtr (handle, underflow_callback_offset, ptr);
-            }
-        }
-
-        static readonly int underflow_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("underflow_callback");
-        
-        Action underflow_callback;
-        delegate void underflow_callback_delegate(IntPtr handle);
-        underflow_callback_delegate underflow_callback_native;
-
-        // FIXME: this should be taken care in more centralized/decent manner... we don't want to write
-        // this kind of code anywhere we need string marshaling.
-        List<IntPtr> allocated_hglobals = new List<IntPtr>();
-
-        public string Name {
-            get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, name_offset)); }
-            set
-            {
-                unsafe
-                {
-                    var existing = Marshal.ReadIntPtr(handle, name_offset);
-                    if (allocated_hglobals.Contains(existing))
-                    {
-                        allocated_hglobals.Remove(existing);
-                        Marshal.FreeHGlobal(existing);
-                    }
-
-                    var ptr = Marshal.StringToHGlobalAnsi(value);
-                    Marshal.WriteIntPtr(handle, name_offset, ptr);
-                    allocated_hglobals.Add(ptr);
-                }
-            }
-        }
-
-        static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("name");
-
-        public bool NonTerminalHint
-        {
-            get { return Marshal.ReadInt32(handle, non_terminal_hint_offset) != 0; }
-        }
-
-        static readonly int non_terminal_hint_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("non_terminal_hint");
-
-        public int BytesPerFrame
-        {
-            get { return Marshal.ReadInt32(handle, bytes_per_frame_offset); }
-        }
-
-        static readonly int bytes_per_frame_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("bytes_per_frame");
-
-        public int BytesPerSample
-        {
-            get { return Marshal.ReadInt32(handle, bytes_per_sample_offset); }
-        }
-
-        static readonly int bytes_per_sample_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("bytes_per_sample");
-
-        public string LayoutErrorMessage
-        {
-            get
-            {
-                var code = (SoundIoError)Marshal.ReadInt32(handle, layout_error_offset);
-
-                return code == SoundIoError.SoundIoErrorNone ? null : Marshal.PtrToStringAnsi(Natives.soundio_strerror((int)code));
-            }
-        }
-
-        static readonly int layout_error_offset = (int)Marshal.OffsetOf<SoundIoOutStream> ("layout_error");
-
-        // functions
-
-        public void Open ()
-        {
-            var ret = (SoundIoError)Natives.soundio_outstream_open(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void Start ()
-        {
-            var ret = (SoundIoError)Natives.soundio_outstream_start(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public SoundIOChannelAreas BeginWrite(ref int frameCount)
-        {
-            IntPtr ptrs             = default;
-            int    nativeFrameCount = frameCount;
-
-            unsafe
-            {
-                var frameCountPtr = &nativeFrameCount;
-                var ptrptr        = &ptrs;
-                var ret           = (SoundIoError)Natives.soundio_outstream_begin_write(handle, (IntPtr)ptrptr, (IntPtr)frameCountPtr);
-
-                frameCount = *frameCountPtr;
-
-                if (ret != SoundIoError.SoundIoErrorNone)
-                {
-                    throw new SoundIOException(ret);
-                }
-
-                return new SoundIOChannelAreas(ptrs, Layout.ChannelCount, frameCount);
-            }
-        }
-
-        public void EndWrite ()
-        {
-            var ret = (SoundIoError)Natives.soundio_outstream_end_write(handle);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public void ClearBuffer ()
-        {
-            _ = Natives.soundio_outstream_clear_buffer(handle);
-        }
-
-        public void Pause (bool pause)
-        {
-            var ret = (SoundIoError)Natives.soundio_outstream_pause(handle, pause);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-
-        public double GetLatency ()
-        {
-            unsafe
-            {
-                double* dptr = null;
-                IntPtr  p    = new IntPtr(dptr);
-
-                var ret = (SoundIoError)Natives.soundio_outstream_get_latency(handle, p);
-                if (ret != SoundIoError.SoundIoErrorNone)
-                {
-                    throw new SoundIOException(ret);
-                }
-
-                dptr = (double*)p;
-
-                return *dptr;
-            }
-        }
-
-        public void SetVolume (double volume)
-        {
-            var ret = (SoundIoError)Natives.soundio_outstream_set_volume(handle, volume);
-            if (ret != SoundIoError.SoundIoErrorNone)
-            {
-                throw new SoundIOException(ret);
-            }
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIORingBuffer.cs

@@ -1,58 +0,0 @@
-using System;
-namespace SoundIOSharp
-{
-    public class SoundIORingBuffer : IDisposable
-    {
-        internal SoundIORingBuffer(IntPtr handle)
-        {
-            this.handle = handle;
-        }
-
-        IntPtr handle;
-
-        public int Capacity
-        {
-            get { return Natives.soundio_ring_buffer_capacity(handle); }
-        }
-
-        public void Clear()
-        {
-            Natives.soundio_ring_buffer_clear(handle);
-        }
-
-        public void Dispose()
-        {
-            Natives.soundio_ring_buffer_destroy(handle);
-        }
-
-        public int FillCount
-        {
-            get { return Natives.soundio_ring_buffer_fill_count(handle); }
-        }
-
-        public int FreeCount
-        {
-            get { return Natives.soundio_ring_buffer_free_count(handle); }
-        }
-
-        public IntPtr ReadPointer
-        {
-            get { return Natives.soundio_ring_buffer_read_ptr(handle); }
-        }
-
-        public IntPtr WritePointer
-        {
-            get { return Natives.soundio_ring_buffer_write_ptr(handle); }
-        }
-
-        public void AdvanceReadPointer(int count)
-        {
-            Natives.soundio_ring_buffer_advance_read_ptr(handle, count);
-        }
-
-        public void AdvanceWritePointer(int count)
-        {
-            Natives.soundio_ring_buffer_advance_write_ptr(handle, count);
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/SoundIOSampleRateRange.cs

@@ -1,14 +0,0 @@
-namespace SoundIOSharp
-{
-    public struct SoundIOSampleRateRange
-    {
-        internal SoundIOSampleRateRange(int min, int max)
-        {
-            Min = min;
-            Max = max;
-        }
-
-        public readonly int Min;
-        public readonly int Max;
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/libsoundio/libsoundio-interop.cs

@@ -1,643 +0,0 @@
-// This source file is generated by nclang PInvokeGenerator.
-using System;
-using System.Runtime.InteropServices;
-using delegate0 = SoundIOSharp.Delegates.delegate0;
-using delegate1 = SoundIOSharp.Delegates.delegate1;
-using delegate2 = SoundIOSharp.Delegates.delegate2;
-using delegate3 = SoundIOSharp.Delegates.delegate3;
-using delegate4 = SoundIOSharp.Delegates.delegate4;
-using delegate5 = SoundIOSharp.Delegates.delegate5;
-using delegate6 = SoundIOSharp.Delegates.delegate6;
-using delegate7 = SoundIOSharp.Delegates.delegate7;
-using delegate8 = SoundIOSharp.Delegates.delegate8;
-using delegate9 = SoundIOSharp.Delegates.delegate9;
-
-namespace SoundIOSharp
-{
-    enum SoundIoError // soundio.h (72, 6)
-    {
-        SoundIoErrorNone = 0,
-        SoundIoErrorNoMem = 1,
-        SoundIoErrorInitAudioBackend = 2,
-        SoundIoErrorSystemResources = 3,
-        SoundIoErrorOpeningDevice = 4,
-        SoundIoErrorNoSuchDevice = 5,
-        SoundIoErrorInvalid = 6,
-        SoundIoErrorBackendUnavailable = 7,
-        SoundIoErrorStreaming = 8,
-        SoundIoErrorIncompatibleDevice = 9,
-        SoundIoErrorNoSuchClient = 10,
-        SoundIoErrorIncompatibleBackend = 11,
-        SoundIoErrorBackendDisconnected = 12,
-        SoundIoErrorInterrupted = 13,
-        SoundIoErrorUnderflow = 14,
-        SoundIoErrorEncodingString = 15,
-    }
-
-    enum SoundIoChannelId // soundio.h (106, 6)
-    {
-        SoundIoChannelIdInvalid = 0,
-        SoundIoChannelIdFrontLeft = 1,
-        SoundIoChannelIdFrontRight = 2,
-        SoundIoChannelIdFrontCenter = 3,
-        SoundIoChannelIdLfe = 4,
-        SoundIoChannelIdBackLeft = 5,
-        SoundIoChannelIdBackRight = 6,
-        SoundIoChannelIdFrontLeftCenter = 7,
-        SoundIoChannelIdFrontRightCenter = 8,
-        SoundIoChannelIdBackCenter = 9,
-        SoundIoChannelIdSideLeft = 10,
-        SoundIoChannelIdSideRight = 11,
-        SoundIoChannelIdTopCenter = 12,
-        SoundIoChannelIdTopFrontLeft = 13,
-        SoundIoChannelIdTopFrontCenter = 14,
-        SoundIoChannelIdTopFrontRight = 15,
-        SoundIoChannelIdTopBackLeft = 16,
-        SoundIoChannelIdTopBackCenter = 17,
-        SoundIoChannelIdTopBackRight = 18,
-        SoundIoChannelIdBackLeftCenter = 19,
-        SoundIoChannelIdBackRightCenter = 20,
-        SoundIoChannelIdFrontLeftWide = 21,
-        SoundIoChannelIdFrontRightWide = 22,
-        SoundIoChannelIdFrontLeftHigh = 23,
-        SoundIoChannelIdFrontCenterHigh = 24,
-        SoundIoChannelIdFrontRightHigh = 25,
-        SoundIoChannelIdTopFrontLeftCenter = 26,
-        SoundIoChannelIdTopFrontRightCenter = 27,
-        SoundIoChannelIdTopSideLeft = 28,
-        SoundIoChannelIdTopSideRight = 29,
-        SoundIoChannelIdLeftLfe = 30,
-        SoundIoChannelIdRightLfe = 31,
-        SoundIoChannelIdLfe2 = 32,
-        SoundIoChannelIdBottomCenter = 33,
-        SoundIoChannelIdBottomLeftCenter = 34,
-        SoundIoChannelIdBottomRightCenter = 35,
-        SoundIoChannelIdMsMid = 36,
-        SoundIoChannelIdMsSide = 37,
-        SoundIoChannelIdAmbisonicW = 38,
-        SoundIoChannelIdAmbisonicX = 39,
-        SoundIoChannelIdAmbisonicY = 40,
-        SoundIoChannelIdAmbisonicZ = 41,
-        SoundIoChannelIdXyX = 42,
-        SoundIoChannelIdXyY = 43,
-        SoundIoChannelIdHeadphonesLeft = 44,
-        SoundIoChannelIdHeadphonesRight = 45,
-        SoundIoChannelIdClickTrack = 46,
-        SoundIoChannelIdForeignLanguage = 47,
-        SoundIoChannelIdHearingImpaired = 48,
-        SoundIoChannelIdNarration = 49,
-        SoundIoChannelIdHaptic = 50,
-        SoundIoChannelIdDialogCentricMix = 51,
-        SoundIoChannelIdAux = 52,
-        SoundIoChannelIdAux0 = 53,
-        SoundIoChannelIdAux1 = 54,
-        SoundIoChannelIdAux2 = 55,
-        SoundIoChannelIdAux3 = 56,
-        SoundIoChannelIdAux4 = 57,
-        SoundIoChannelIdAux5 = 58,
-        SoundIoChannelIdAux6 = 59,
-        SoundIoChannelIdAux7 = 60,
-        SoundIoChannelIdAux8 = 61,
-        SoundIoChannelIdAux9 = 62,
-        SoundIoChannelIdAux10 = 63,
-        SoundIoChannelIdAux11 = 64,
-        SoundIoChannelIdAux12 = 65,
-        SoundIoChannelIdAux13 = 66,
-        SoundIoChannelIdAux14 = 67,
-        SoundIoChannelIdAux15 = 68,
-    }
-
-    enum SoundIoChannelLayoutId // soundio.h (189, 6)
-    {
-        SoundIoChannelLayoutIdMono = 0,
-        SoundIoChannelLayoutIdStereo = 1,
-        SoundIoChannelLayoutId2Point1 = 2,
-        SoundIoChannelLayoutId3Point0 = 3,
-        SoundIoChannelLayoutId3Point0Back = 4,
-        SoundIoChannelLayoutId3Point1 = 5,
-        SoundIoChannelLayoutId4Point0 = 6,
-        SoundIoChannelLayoutIdQuad = 7,
-        SoundIoChannelLayoutIdQuadSide = 8,
-        SoundIoChannelLayoutId4Point1 = 9,
-        SoundIoChannelLayoutId5Point0Back = 10,
-        SoundIoChannelLayoutId5Point0Side = 11,
-        SoundIoChannelLayoutId5Point1 = 12,
-        SoundIoChannelLayoutId5Point1Back = 13,
-        SoundIoChannelLayoutId6Point0Side = 14,
-        SoundIoChannelLayoutId6Point0Front = 15,
-        SoundIoChannelLayoutIdHexagonal = 16,
-        SoundIoChannelLayoutId6Point1 = 17,
-        SoundIoChannelLayoutId6Point1Back = 18,
-        SoundIoChannelLayoutId6Point1Front = 19,
-        SoundIoChannelLayoutId7Point0 = 20,
-        SoundIoChannelLayoutId7Point0Front = 21,
-        SoundIoChannelLayoutId7Point1 = 22,
-        SoundIoChannelLayoutId7Point1Wide = 23,
-        SoundIoChannelLayoutId7Point1WideBack = 24,
-        SoundIoChannelLayoutIdOctagonal = 25,
-    }
-
-    enum SoundIoBackend // soundio.h (218, 6)
-    {
-        SoundIoBackendNone = 0,
-        SoundIoBackendJack = 1,
-        SoundIoBackendPulseAudio = 2,
-        SoundIoBackendAlsa = 3,
-        SoundIoBackendCoreAudio = 4,
-        SoundIoBackendWasapi = 5,
-        SoundIoBackendDummy = 6,
-    }
-
-    enum SoundIoDeviceAim // soundio.h (228, 6)
-    {
-        SoundIoDeviceAimInput = 0,
-        SoundIoDeviceAimOutput = 1,
-    }
-
-    enum SoundIoFormat // soundio.h (235, 6)
-    {
-        SoundIoFormatInvalid = 0,
-        SoundIoFormatS8 = 1,
-        SoundIoFormatU8 = 2,
-        SoundIoFormatS16LE = 3,
-        SoundIoFormatS16BE = 4,
-        SoundIoFormatU16LE = 5,
-        SoundIoFormatU16BE = 6,
-        SoundIoFormatS24LE = 7,
-        SoundIoFormatS24BE = 8,
-        SoundIoFormatU24LE = 9,
-        SoundIoFormatU24BE = 10,
-        SoundIoFormatS32LE = 11,
-        SoundIoFormatS32BE = 12,
-        SoundIoFormatU32LE = 13,
-        SoundIoFormatU32BE = 14,
-        SoundIoFormatFloat32LE = 15,
-        SoundIoFormatFloat32BE = 16,
-        SoundIoFormatFloat64LE = 17,
-        SoundIoFormatFloat64BE = 18,
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoChannelLayout // soundio.h (306, 8)
-    {
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @name;
-        public int @channel_count;
-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)]
-        [CTypeDetails("ConstArrayOf<SoundIoChannelId>")] public SoundIoChannelId[] @channels;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoSampleRateRange // soundio.h (313, 8)
-    {
-        public int @min;
-        public int @max;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoChannelArea // soundio.h (319, 8)
-    {
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @ptr;
-        public int @step;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIo // soundio.h (328, 8)
-    {
-        [CTypeDetails("Pointer<void>")] public System.IntPtr @userdata;
-        [CTypeDetails("Pointer<void (SoundIo *)>")] public delegate0 @on_devices_change;
-        [CTypeDetails("Pointer<void (SoundIo *, int)>")] public delegate1 @on_backend_disconnect;
-        [CTypeDetails("Pointer<void (SoundIo *)>")] public Delegates.delegate0 @on_events_signal;
-        public SoundIoBackend @current_backend;
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @app_name;
-        [CTypeDetails("Pointer<void ()>")] public delegate2 @emit_rtprio_warning;
-        [CTypeDetails("Pointer<void (const char *)>")] public delegate3 @jack_info_callback;
-        [CTypeDetails("Pointer<void (const char *)>")] public Delegates.delegate3 @jack_error_callback;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoDevice // soundio.h (387, 8)
-    {
-        [CTypeDetails("Pointer<SoundIo>")] public System.IntPtr @soundio;
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @id;
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @name;
-        public SoundIoDeviceAim @aim;
-        [CTypeDetails("Pointer<SoundIoChannelLayout>")] public System.IntPtr @layouts;
-        public int @layout_count;
-        public SoundIoChannelLayout @current_layout;
-        [CTypeDetails("Pointer<SoundIoFormat>")] public System.IntPtr @formats;
-        public int @format_count;
-        public SoundIoFormat @current_format;
-        [CTypeDetails("Pointer<SoundIoSampleRateRange>")] public System.IntPtr @sample_rates;
-        public int @sample_rate_count;
-        public int @sample_rate_current;
-        public double @software_latency_min;
-        public double @software_latency_max;
-        public double @software_latency_current;
-        public bool @is_raw;
-        public int @ref_count;
-        public int @probe_error;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoOutStream // soundio.h (497, 8)
-    {
-        [CTypeDetails("Pointer<SoundIoDevice>")] public System.IntPtr @device;
-        public SoundIoFormat @format;
-        public int @sample_rate;
-        public SoundIoChannelLayout @layout;
-        public double @software_latency;
-        public float @volume;
-        [CTypeDetails("Pointer<void>")] public System.IntPtr @userdata;
-        [CTypeDetails("Pointer<void (SoundIoOutStream *, int, int)>")] public delegate4 @write_callback;
-        [CTypeDetails("Pointer<void (SoundIoOutStream *)>")] public delegate5 @underflow_callback;
-        [CTypeDetails("Pointer<void (SoundIoOutStream *, int)>")] public delegate6 @error_callback;
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @name;
-        public bool @non_terminal_hint;
-        public int @bytes_per_frame;
-        public int @bytes_per_sample;
-        public int @layout_error;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoInStream // soundio.h (600, 8)
-    {
-        [CTypeDetails("Pointer<SoundIoDevice>")] public System.IntPtr @device;
-        public SoundIoFormat @format;
-        public int @sample_rate;
-        public SoundIoChannelLayout @layout;
-        public double @software_latency;
-        [CTypeDetails("Pointer<void>")] public System.IntPtr @userdata;
-        [CTypeDetails("Pointer<void (SoundIoInStream *, int, int)>")] public delegate7 @read_callback;
-        [CTypeDetails("Pointer<void (SoundIoInStream *)>")] public delegate8 @overflow_callback;
-        [CTypeDetails("Pointer<void (SoundIoInStream *, int)>")] public delegate9 @error_callback;
-        [CTypeDetails("Pointer<byte>")] public System.IntPtr @name;
-        public bool @non_terminal_hint;
-        public int @bytes_per_frame;
-        public int @bytes_per_sample;
-        public int @layout_error;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SoundIoRingBuffer // soundio.h (1170, 8)
-    {
-    }
-
-    partial class Natives
-    {
-        const string LibraryName = "libsoundio";
-        // function soundio_version_string - soundio.h (682, 28)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_version_string();
-
-        // function soundio_version_major - soundio.h (684, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_version_major();
-
-        // function soundio_version_minor - soundio.h (686, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_version_minor();
-
-        // function soundio_version_patch - soundio.h (688, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_version_patch();
-
-        // function soundio_create - soundio.h (694, 32)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_create();
-
-        // function soundio_destroy - soundio.h (695, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_destroy([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_connect - soundio.h (705, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_connect([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_connect_backend - soundio.h (717, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_connect_backend([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, SoundIoBackend @backend);
-
-        // function soundio_disconnect - soundio.h (718, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_disconnect([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_strerror - soundio.h (721, 28)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_strerror(int @error);
-
-        // function soundio_backend_name - soundio.h (723, 28)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_backend_name(SoundIoBackend @backend);
-
-        // function soundio_backend_count - soundio.h (726, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_backend_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_get_backend - soundio.h (729, 36)
-        [DllImport(LibraryName)]
-        internal static extern SoundIoBackend soundio_get_backend([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, int @index);
-
-        // function soundio_have_backend - soundio.h (732, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_have_backend(SoundIoBackend @backend);
-
-        // function soundio_flush_events - soundio.h (756, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_flush_events([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_wait_events - soundio.h (760, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_wait_events([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_wakeup - soundio.h (763, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_wakeup([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_force_device_scan - soundio.h (780, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_force_device_scan([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_channel_layout_equal - soundio.h (787, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_channel_layout_equal([CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @a, [CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @b);
-
-        // function soundio_get_channel_name - soundio.h (791, 28)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_get_channel_name(SoundIoChannelId @id);
-
-        // function soundio_parse_channel_id - soundio.h (795, 38)
-        [DllImport(LibraryName)]
-        internal static extern SoundIoChannelId soundio_parse_channel_id([CTypeDetails("Pointer<byte>")]System.IntPtr @str, int @str_len);
-
-        // function soundio_channel_layout_builtin_count - soundio.h (798, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_channel_layout_builtin_count();
-
-        // function soundio_channel_layout_get_builtin - soundio.h (803, 51)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_channel_layout_get_builtin(int @index);
-
-        // function soundio_channel_layout_get_default - soundio.h (806, 51)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_channel_layout_get_default(int @channel_count);
-
-        // function soundio_channel_layout_find_channel - soundio.h (809, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_channel_layout_find_channel([CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @layout, SoundIoChannelId @channel);
-
-        // function soundio_channel_layout_detect_builtin - soundio.h (814, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_channel_layout_detect_builtin([CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @layout);
-
-        // function soundio_best_matching_channel_layout - soundio.h (819, 51)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_best_matching_channel_layout([CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @preferred_layouts, int @preferred_layout_count, [CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @available_layouts, int @available_layout_count);
-
-        // function soundio_sort_channel_layouts - soundio.h (824, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_sort_channel_layouts([CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @layouts, int @layout_count);
-
-        // function soundio_get_bytes_per_sample - soundio.h (830, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_get_bytes_per_sample(SoundIoFormat @format);
-
-        // function soundio_get_bytes_per_frame - soundio.h (833, 19)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_get_bytes_per_frame(SoundIoFormat @format, int @channel_count);
-
-        // function soundio_get_bytes_per_second - soundio.h (838, 19)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_get_bytes_per_second(SoundIoFormat @format, int @channel_count, int @sample_rate);
-
-        // function soundio_format_string - soundio.h (845, 29)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_format_string(SoundIoFormat @format);
-
-        // function soundio_input_device_count - soundio.h (861, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_input_device_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_output_device_count - soundio.h (864, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_output_device_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_get_input_device - soundio.h (870, 38)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_get_input_device([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, int @index);
-
-        // function soundio_get_output_device - soundio.h (875, 38)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_get_output_device([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, int @index);
-
-        // function soundio_default_input_device_index - soundio.h (880, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_default_input_device_index([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_default_output_device_index - soundio.h (885, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_default_output_device_index([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
-
-        // function soundio_device_ref - soundio.h (888, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_device_ref([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
-
-        // function soundio_device_unref - soundio.h (891, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_device_unref([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
-
-        // function soundio_device_equal - soundio.h (895, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_device_equal([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @a, [CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @b);
-
-        // function soundio_device_sort_channel_layouts - soundio.h (900, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_device_sort_channel_layouts([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
-
-        // function soundio_device_supports_format - soundio.h (904, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_device_supports_format([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device, SoundIoFormat @format);
-
-        // function soundio_device_supports_layout - soundio.h (909, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_device_supports_layout([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device, [CTypeDetails("Pointer<SoundIoChannelLayout>")]System.IntPtr @layout);
-
-        // function soundio_device_supports_sample_rate - soundio.h (914, 21)
-        [DllImport(LibraryName)]
-        internal static extern bool soundio_device_supports_sample_rate([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device, int @sample_rate);
-
-        // function soundio_device_nearest_sample_rate - soundio.h (919, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_device_nearest_sample_rate([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device, int @sample_rate);
-
-        // function soundio_outstream_create - soundio.h (929, 41)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_outstream_create([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
-
-        // function soundio_outstream_destroy - soundio.h (931, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_outstream_destroy([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
-
-        // function soundio_outstream_open - soundio.h (954, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_open([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
-
-        // function soundio_outstream_start - soundio.h (965, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_start([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
-
-        // function soundio_outstream_begin_write - soundio.h (997, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_begin_write([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream, [CTypeDetails("Pointer<System.IntPtr>")]System.IntPtr @areas, [CTypeDetails("Pointer<int>")]System.IntPtr @frame_count);
-
-        // function soundio_outstream_end_write - soundio.h (1009, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_end_write([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
-
-        // function soundio_outstream_clear_buffer - soundio.h (1024, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_clear_buffer([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
-
-        // function soundio_outstream_pause - soundio.h (1045, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_pause([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream, bool @pause);
-
-        // function soundio_outstream_get_latency - soundio.h (1058, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_get_latency([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream, [CTypeDetails("Pointer<double>")]System.IntPtr @out_latency);
-
-        // function soundio_outstream_set_volume - soundio.h (1061, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_outstream_set_volume([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream, double @volume);
-
-        // function soundio_instream_create - soundio.h (1071, 40)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_instream_create([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
-
-        // function soundio_instream_destroy - soundio.h (1073, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_instream_destroy([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
-
-        // function soundio_instream_open - soundio.h (1093, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_open([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
-
-        // function soundio_instream_start - soundio.h (1102, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_start([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
-
-        // function soundio_instream_begin_read - soundio.h (1133, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_begin_read([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream, [CTypeDetails("Pointer<System.IntPtr>")]System.IntPtr @areas, [CTypeDetails("Pointer<int>")]System.IntPtr @frame_count);
-
-        // function soundio_instream_end_read - soundio.h (1143, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_end_read([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
-
-        // function soundio_instream_pause - soundio.h (1156, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_pause([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream, bool @pause);
-
-        // function soundio_instream_get_latency - soundio.h (1166, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_instream_get_latency([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream, [CTypeDetails("Pointer<double>")]System.IntPtr @out_latency);
-
-        // function soundio_ring_buffer_create - soundio.h (1181, 42)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_ring_buffer_create([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, int @requested_capacity);
-
-        // function soundio_ring_buffer_destroy - soundio.h (1182, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_ring_buffer_destroy([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_capacity - soundio.h (1186, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_ring_buffer_capacity([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_write_ptr - soundio.h (1189, 22)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_ring_buffer_write_ptr([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_advance_write_ptr - soundio.h (1191, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_ring_buffer_advance_write_ptr([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer, int @count);
-
-        // function soundio_ring_buffer_read_ptr - soundio.h (1194, 22)
-        [DllImport(LibraryName)]
-        internal static extern System.IntPtr soundio_ring_buffer_read_ptr([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_advance_read_ptr - soundio.h (1196, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_ring_buffer_advance_read_ptr([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer, int @count);
-
-        // function soundio_ring_buffer_fill_count - soundio.h (1199, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_ring_buffer_fill_count([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_free_count - soundio.h (1202, 20)
-        [DllImport(LibraryName)]
-        internal static extern int soundio_ring_buffer_free_count([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-        // function soundio_ring_buffer_clear - soundio.h (1205, 21)
-        [DllImport(LibraryName)]
-        internal static extern void soundio_ring_buffer_clear([CTypeDetails("Pointer<SoundIoRingBuffer>")]System.IntPtr @ring_buffer);
-
-    }
-
-    class Delegates
-    {
-        public delegate void delegate0(System.IntPtr p0);
-        public delegate void delegate1(System.IntPtr p0, int p1);
-        public delegate void delegate2();
-        public delegate void delegate3(System.IntPtr p0);
-        public delegate void delegate4(System.IntPtr p0, int p1, int p2);
-        public delegate void delegate5(System.IntPtr p0);
-        public delegate void delegate6(System.IntPtr p0, int p1);
-        public delegate void delegate7(System.IntPtr p0, int p1, int p2);
-        public delegate void delegate8(System.IntPtr p0);
-        public delegate void delegate9(System.IntPtr p0, int p1);
-    }
-
-    public struct Pointer<T>
-    {
-        public IntPtr Handle;
-        public static implicit operator IntPtr(Pointer<T> value) { return value.Handle; }
-        public static implicit operator Pointer<T>(IntPtr value) { return new Pointer<T>(value); }
-
-        public Pointer(IntPtr handle)
-        {
-            Handle = handle;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Pointer<T> && this == (Pointer<T>)obj;
-        }
-
-        public override int GetHashCode()
-        {
-            return (int)Handle;
-        }
-
-        public static bool operator ==(Pointer<T> p1, Pointer<T> p2)
-        {
-            return p1.Handle == p2.Handle;
-        }
-
-        public static bool operator !=(Pointer<T> p1, Pointer<T> p2)
-        {
-            return p1.Handle != p2.Handle;
-        }
-    }
-    public struct ArrayOf<T> { }
-    public struct ConstArrayOf<T> { }
-    public class CTypeDetailsAttribute : Attribute
-    {
-        public CTypeDetailsAttribute(string value)
-        {
-            Value = value;
-        }
-
-        public string Value { get; set; }
-    }
-
-}

Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceDriver.cs

@@ -1,19 +1,20 @@
-using Ryujinx.Audio.Common;
+using Ryujinx.Audio.Backends.SoundIo.Native;
+using Ryujinx.Audio.Common;
 using Ryujinx.Audio.Integration;
 using Ryujinx.Memory;
-using SoundIOSharp;
 using System;
 using System.Collections.Concurrent;
 using System.Threading;
 
 using static Ryujinx.Audio.Integration.IHardwareDeviceDriver;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
 
 namespace Ryujinx.Audio.Backends.SoundIo
 {
     public class SoundIoHardwareDeviceDriver : IHardwareDeviceDriver
     {
-        private readonly SoundIO _audioContext;
-        private readonly SoundIODevice _audioDevice;
+        private readonly SoundIoContext _audioContext;
+        private readonly SoundIoDeviceContext _audioDevice;
         private readonly ManualResetEvent _updateRequiredEvent;
         private readonly ManualResetEvent _pauseEvent;
         private readonly ConcurrentDictionary<SoundIoHardwareDeviceSession, byte> _sessions;
@@ -21,7 +22,7 @@ namespace Ryujinx.Audio.Backends.SoundIo
 
         public SoundIoHardwareDeviceDriver()
         {
-            _audioContext = new SoundIO();
+            _audioContext = SoundIoContext.Create();
             _updateRequiredEvent = new ManualResetEvent(false);
             _pauseEvent = new ManualResetEvent(true);
             _sessions = new ConcurrentDictionary<SoundIoHardwareDeviceSession, byte>();
@@ -29,24 +30,23 @@ namespace Ryujinx.Audio.Backends.SoundIo
             _audioContext.Connect();
             _audioContext.FlushEvents();
 
-            _audioDevice = FindNonRawDefaultAudioDevice(_audioContext, true);
+            _audioDevice = FindValidAudioDevice(_audioContext, true);
         }
 
         public static bool IsSupported => IsSupportedInternal();
 
         private static bool IsSupportedInternal()
         {
-            SoundIO context = null;
-            SoundIODevice device = null;
-            SoundIOOutStream stream = null;
+            SoundIoContext context = null;
+            SoundIoDeviceContext device = null;
+            SoundIoOutStreamContext stream = null;
 
             bool backendDisconnected = false;
 
             try
             {
-                context = new SoundIO();
-
-                context.OnBackendDisconnect = (i) =>
+                context = SoundIoContext.Create();
+                context.OnBackendDisconnect = err =>
                 {
                     backendDisconnected = true;
                 };
@@ -64,7 +64,7 @@ namespace Ryujinx.Audio.Backends.SoundIo
                     return false;
                 }
 
-                device = FindNonRawDefaultAudioDevice(context);
+                device = FindValidAudioDevice(context);
 
                 if (device == null || backendDisconnected)
                 {
@@ -86,30 +86,23 @@ namespace Ryujinx.Audio.Backends.SoundIo
             }
             finally
             {
-                if (stream != null)
-                {
-                    stream.Dispose();
-                }
-
-                if (context != null)
-                {
-                    context.Dispose();
-                }
+                stream?.Dispose();
+                context?.Dispose();
             }
         }
 
-        private static SoundIODevice FindNonRawDefaultAudioDevice(SoundIO audioContext, bool fallback = false)
+        private static SoundIoDeviceContext FindValidAudioDevice(SoundIoContext audioContext, bool fallback = false)
         {
-            SoundIODevice defaultAudioDevice = audioContext.GetOutputDevice(audioContext.DefaultOutputDeviceIndex);
+            SoundIoDeviceContext defaultAudioDevice = audioContext.GetOutputDevice(audioContext.DefaultOutputDeviceIndex);
 
             if (!defaultAudioDevice.IsRaw)
             {
                 return defaultAudioDevice;
             }
 
-            for (int i = 0; i < audioContext.BackendCount; i++)
+            for (int i = 0; i < audioContext.OutputDeviceCount; i++)
             {
-                SoundIODevice audioDevice = audioContext.GetOutputDevice(i);
+                SoundIoDeviceContext audioDevice = audioContext.GetOutputDevice(i);
 
                 if (audioDevice.Id == defaultAudioDevice.Id && !audioDevice.IsRaw)
                 {
@@ -161,22 +154,22 @@ namespace Ryujinx.Audio.Backends.SoundIo
             return _sessions.TryRemove(session, out _);
         }
 
-        public static SoundIOFormat GetSoundIoFormat(SampleFormat format)
+        public static SoundIoFormat GetSoundIoFormat(SampleFormat format)
         {
             return format switch
             {
-                SampleFormat.PcmInt8 => SoundIOFormat.S8,
-                SampleFormat.PcmInt16 => SoundIOFormat.S16LE,
-                SampleFormat.PcmInt24 => SoundIOFormat.S24LE,
-                SampleFormat.PcmInt32 => SoundIOFormat.S32LE,
-                SampleFormat.PcmFloat => SoundIOFormat.Float32LE,
+                SampleFormat.PcmInt8 => SoundIoFormat.S8,
+                SampleFormat.PcmInt16 => SoundIoFormat.S16LE,
+                SampleFormat.PcmInt24 => SoundIoFormat.S24LE,
+                SampleFormat.PcmInt32 => SoundIoFormat.S32LE,
+                SampleFormat.PcmFloat => SoundIoFormat.Float32LE,
                 _ => throw new ArgumentException ($"Unsupported sample format {format}"),
             };
         }
 
-        internal SoundIOOutStream OpenStream(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount)
+        internal SoundIoOutStreamContext OpenStream(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount)
         {
-            SoundIOFormat driverSampleFormat = GetSoundIoFormat(requestedSampleFormat);
+            SoundIoFormat driverSampleFormat = GetSoundIoFormat(requestedSampleFormat);
 
             if (!_audioDevice.SupportsSampleRate((int)requestedSampleRate))
             {
@@ -193,10 +186,10 @@ namespace Ryujinx.Audio.Backends.SoundIo
                 throw new ArgumentException($"This sound device does not support channel count {requestedChannelCount}");
             }
 
-            SoundIOOutStream result = _audioDevice.CreateOutStream();
+            SoundIoOutStreamContext result = _audioDevice.CreateOutStream();
 
             result.Name = "Ryujinx";
-            result.Layout = SoundIOChannelLayout.GetDefault((int)requestedChannelCount);
+            result.Layout = SoundIoChannelLayout.GetDefaultValue((int)requestedChannelCount);
             result.Format = driverSampleFormat;
             result.SampleRate = (int)requestedSampleRate;
 

Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceSession.cs

@@ -1,11 +1,12 @@
 using Ryujinx.Audio.Backends.Common;
+using Ryujinx.Audio.Backends.SoundIo.Native;
 using Ryujinx.Audio.Common;
 using Ryujinx.Memory;
-using SoundIOSharp;
 using System;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
 
 namespace Ryujinx.Audio.Backends.SoundIo
 {
@@ -13,7 +14,7 @@ namespace Ryujinx.Audio.Backends.SoundIo
     {
         private SoundIoHardwareDeviceDriver _driver;
         private ConcurrentQueue<SoundIoAudioBuffer> _queuedBuffers;
-        private SoundIOOutStream _outputStream;
+        private SoundIoOutStreamContext _outputStream;
         private DynamicRingBuffer _ringBuffer;
         private ulong _playedSampleCount;
         private ManualResetEvent _updateRequiredEvent;
@@ -106,9 +107,9 @@ namespace Ryujinx.Audio.Backends.SoundIo
                 return;
             }
 
-            SoundIOChannelAreas areas = _outputStream.BeginWrite(ref frameCount);
+            Span<SoundIoChannelArea> areas = _outputStream.BeginWrite(ref frameCount);
 
-            int channelCount = areas.ChannelCount;
+            int channelCount = areas.Length;
 
             byte[] samples = new byte[frameCount * bytesPerFrame];
 
@@ -117,12 +118,12 @@ namespace Ryujinx.Audio.Backends.SoundIo
             // This is a huge ugly block of code, but we save
             // a significant amount of time over the generic
             // loop that handles other channel counts.
-            // TODO: Is this still right in 2021?
+            // TODO: Is this still right in 2022?
 
             // Mono
             if (channelCount == 1)
             {
-                SoundIOChannelArea area = areas.GetArea(0);
+                ref SoundIoChannelArea area = ref areas[0];
 
                 fixed (byte* srcptr = samples)
                 {
@@ -167,8 +168,8 @@ namespace Ryujinx.Audio.Backends.SoundIo
             // Stereo
             else if (channelCount == 2)
             {
-                SoundIOChannelArea area1 = areas.GetArea(0);
-                SoundIOChannelArea area2 = areas.GetArea(1);
+                ref SoundIoChannelArea area1 = ref areas[0];
+                ref SoundIoChannelArea area2 = ref areas[1];
 
                 fixed (byte* srcptr = samples)
                 {
@@ -233,12 +234,12 @@ namespace Ryujinx.Audio.Backends.SoundIo
             // Surround
             else if (channelCount == 6)
             {
-                SoundIOChannelArea area1 = areas.GetArea(0);
-                SoundIOChannelArea area2 = areas.GetArea(1);
-                SoundIOChannelArea area3 = areas.GetArea(2);
-                SoundIOChannelArea area4 = areas.GetArea(3);
-                SoundIOChannelArea area5 = areas.GetArea(4);
-                SoundIOChannelArea area6 = areas.GetArea(5);
+                ref SoundIoChannelArea area1 = ref areas[0];
+                ref SoundIoChannelArea area2 = ref areas[1];
+                ref SoundIoChannelArea area3 = ref areas[2];
+                ref SoundIoChannelArea area4 = ref areas[3];
+                ref SoundIoChannelArea area5 = ref areas[4];
+                ref SoundIoChannelArea area6 = ref areas[5];
 
                 fixed (byte* srcptr = samples)
                 {
@@ -367,24 +368,18 @@ namespace Ryujinx.Audio.Backends.SoundIo
             // Every other channel count
             else
             {
-                SoundIOChannelArea[] channels = new SoundIOChannelArea[channelCount];
-
-                // Obtain the channel area for each channel
-                for (int i = 0; i < channelCount; i++)
-                {
-                    channels[i] = areas.GetArea(i);
-                }
-
                 fixed (byte* srcptr = samples)
                 {
                     for (int frame = 0; frame < frameCount; frame++)
-                        for (int channel = 0; channel < areas.ChannelCount; channel++)
+                    {
+                        for (int channel = 0; channel < areas.Length; channel++)
                         {
                             // Copy channel by channel, frame by frame. This is slow!
-                            Unsafe.CopyBlockUnaligned((byte*)channels[channel].Pointer, srcptr + (frame * bytesPerFrame) + (channel * bytesPerSample), bytesPerSample);
+                            Unsafe.CopyBlockUnaligned((byte*)areas[channel].Pointer, srcptr + (frame * bytesPerFrame) + (channel * bytesPerSample), bytesPerSample);
 
-                            channels[channel].Pointer += channels[channel].Step;
+                            areas[channel].Pointer += areas[channel].Step;
                         }
+                    }
                 }
             }
 

Ryujinx.Audio/Renderer/Common/EffectType.cs

@@ -48,6 +48,11 @@ namespace Ryujinx.Audio.Renderer.Common
         /// <summary>
         /// Effect to capture mixes (via auxiliary buffers).
         /// </summary>
-        CaptureBuffer
+        CaptureBuffer,
+
+        /// <summary>
+        /// Effect applying a compressor filter (DRC).
+        /// </summary>
+        Compressor,
     }
 }

Ryujinx.Audio/Renderer/Common/PerformanceDetailType.cs

@@ -14,6 +14,7 @@ namespace Ryujinx.Audio.Renderer.Common
         Reverb3d,
         PcmFloat,
         Limiter,
-        CaptureBuffer
+        CaptureBuffer,
+        Compressor
     }
 }

Ryujinx.Audio/Renderer/Dsp/Command/CommandType.cs

@@ -31,6 +31,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         LimiterVersion1,
         LimiterVersion2,
         GroupedBiquadFilter,
-        CaptureBuffer
+        CaptureBuffer,
+        Compressor
     }
 }

Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Diagnostics;
+using Ryujinx.Audio.Renderer.Dsp.Effect;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Command
+{
+    public class CompressorCommand : ICommand
+    {
+        private const int FixedPointPrecision = 15;
+
+        public bool Enabled { get; set; }
+
+        public int NodeId { get; }
+
+        public CommandType CommandType => CommandType.Compressor;
+
+        public uint EstimatedProcessingTime { get; set; }
+
+        public CompressorParameter Parameter => _parameter;
+        public Memory<CompressorState> State { get; }
+        public ushort[] OutputBufferIndices { get; }
+        public ushort[] InputBufferIndices { get; }
+        public bool IsEffectEnabled { get; }
+
+        private CompressorParameter _parameter;
+
+        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        {
+            Enabled = true;
+            NodeId = nodeId;
+            _parameter = parameter;
+            State = state;
+
+            IsEffectEnabled = isEnabled;
+
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+
+            for (int i = 0; i < _parameter.ChannelCount; i++)
+            {
+                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
+            }
+        }
+
+        public void Process(CommandList context)
+        {
+            ref CompressorState state = ref State.Span[0];
+
+            if (IsEffectEnabled)
+            {
+                if (_parameter.Status == Server.Effect.UsageState.Invalid)
+                {
+                    state = new CompressorState(ref _parameter);
+                }
+                else if (_parameter.Status == Server.Effect.UsageState.New)
+                {
+                    state.UpdateParameter(ref _parameter);
+                }
+            }
+
+            ProcessCompressor(context, ref state);
+        }
+
+        private unsafe void ProcessCompressor(CommandList context, ref CompressorState state)
+        {
+            Debug.Assert(_parameter.IsChannelCountValid());
+
+            if (IsEffectEnabled && _parameter.IsChannelCountValid())
+            {
+                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
+                ExponentialMovingAverage inputMovingAverage = state.InputMovingAverage;
+                float unknown4 = state.Unknown4;
+                ExponentialMovingAverage compressionGainAverage = state.CompressionGainAverage;
+                float previousCompressionEmaAlpha = state.PreviousCompressionEmaAlpha;
+
+                for (int i = 0; i < _parameter.ChannelCount; i++)
+                {
+                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
+                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
+                }
+
+                for (int sampleIndex = 0; sampleIndex < context.SampleCount; sampleIndex++)
+                {
+                    for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
+                    {
+                        channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex);
+                    }
+
+                    float newMean = inputMovingAverage.Update(FloatingPointHelper.MeanSquare(channelInput), _parameter.InputGain);
+                    float y = FloatingPointHelper.Log10(newMean) * 10.0f;
+                    float z = 0.0f;
+
+                    bool unknown10OutOfRange = false;
+
+                    if (newMean < 1.0e-10f)
+                    {
+                        z = 1.0f;
+
+                        unknown10OutOfRange = state.Unknown10 < -100.0f;
+                    }
+
+                    if (y >= state.Unknown10 || unknown10OutOfRange)
+                    {
+                        float tmpGain;
+
+                        if (y >= state.Unknown14)
+                        {
+                            tmpGain = ((1.0f / Parameter.Ratio) - 1.0f) * (y - Parameter.Threshold);
+                        }
+                        else
+                        {
+                            tmpGain = (y - state.Unknown10) * ((y - state.Unknown10) * -state.CompressorGainReduction);
+                        }
+
+                        z = FloatingPointHelper.DecibelToLinearExtended(tmpGain);
+                    }
+
+                    float unknown4New = z;
+                    float compressionEmaAlpha;
+
+                    if ((unknown4 - z) <= 0.08f)
+                    {
+                        compressionEmaAlpha = Parameter.ReleaseCoefficient;
+
+                        if ((unknown4 - z) >= -0.08f)
+                        {
+                            if (MathF.Abs(compressionGainAverage.Read() - z) >= 0.001f)
+                            {
+                                unknown4New = unknown4;
+                            }
+
+                            compressionEmaAlpha = previousCompressionEmaAlpha;
+                        }
+                    }
+                    else
+                    {
+                        compressionEmaAlpha = Parameter.AttackCoefficient;
+                    }
+
+                    float compressionGain = compressionGainAverage.Update(z, compressionEmaAlpha);
+
+                    for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
+                    {
+                        *((float*)outputBuffers[channelIndex] + sampleIndex) = channelInput[channelIndex] * compressionGain * state.OutputGain;
+                    }
+
+                    unknown4 = unknown4New;
+                    previousCompressionEmaAlpha = compressionEmaAlpha;
+                }
+
+                state.InputMovingAverage = inputMovingAverage;
+                state.Unknown4 = unknown4;
+                state.CompressionGainAverage = compressionGainAverage;
+                state.PreviousCompressionEmaAlpha = previousCompressionEmaAlpha;
+            }
+            else
+            {
+                for (int i = 0; i < Parameter.ChannelCount; i++)
+                {
+                    if (InputBufferIndices[i] != OutputBufferIndices[i])
+                    {
+                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
+                    }
+                }
+            }
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion1.cs

@@ -90,32 +90,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         float inputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (sampleInputMax > state.DectectorAverage[channelIndex])
+                        if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
                             inputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.DectectorAverage[channelIndex] += inputCoefficient * (sampleInputMax - state.DectectorAverage[channelIndex]);
-
+                        float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (state.DectectorAverage[channelIndex] > Parameter.Threshold)
+                        if (detectorValue > Parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / state.DectectorAverage[channelIndex];
+                            attenuation = Parameter.Threshold / detectorValue;
                         }
 
                         float outputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (state.CompressionGain[channelIndex] > attenuation)
+                        if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
                             outputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.CompressionGain[channelIndex] += outputCoefficient * (attenuation - state.CompressionGain[channelIndex]);
+                        float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
                         ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * state.CompressionGain[channelIndex] * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 

Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion2.cs

@@ -101,32 +101,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         float inputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (sampleInputMax > state.DectectorAverage[channelIndex])
+                        if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
                             inputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.DectectorAverage[channelIndex] += inputCoefficient * (sampleInputMax - state.DectectorAverage[channelIndex]);
-
+                        float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (state.DectectorAverage[channelIndex] > Parameter.Threshold)
+                        if (detectorValue > Parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / state.DectectorAverage[channelIndex];
+                            attenuation = Parameter.Threshold / detectorValue;
                         }
 
                         float outputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (state.CompressionGain[channelIndex] > attenuation)
+                        if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
                             outputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.CompressionGain[channelIndex] += outputCoefficient * (attenuation - state.CompressionGain[channelIndex]);
+                        float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
                         ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * state.CompressionGain[channelIndex] * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 
@@ -144,7 +143,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                             ref LimiterStatistics statistics = ref MemoryMarshal.Cast<byte, LimiterStatistics>(ResultState.Span[0].SpecificData)[0];
 
                             statistics.InputMax[channelIndex] = Math.Max(statistics.InputMax[channelIndex], sampleInputMax);
-                            statistics.CompressionGainMin[channelIndex] = Math.Min(statistics.CompressionGainMin[channelIndex], state.CompressionGain[channelIndex]);
+                            statistics.CompressionGainMin[channelIndex] = Math.Min(statistics.CompressionGainMin[channelIndex], compressionGain);
                         }
                     }
                 }

Ryujinx.Audio/Renderer/Dsp/Effect/ExponentialMovingAverage.cs

@@ -0,0 +1,26 @@
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Effect
+{
+    public struct ExponentialMovingAverage
+    {
+        private float _mean;
+
+        public ExponentialMovingAverage(float mean)
+        {
+            _mean = mean;
+        }
+
+        public float Read()
+        {
+            return _mean;
+        }
+
+        public float Update(float value, float alpha)
+        {
+            _mean += alpha * (value - _mean);
+
+            return _mean;
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/FixedPointHelper.cs

@@ -16,6 +16,12 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return (float)value / (1 << qBits);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float ConvertFloat(float value, int qBits)
+        {
+            return value / (1 << qBits);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int ToFixed(float value, int qBits)
         {

Ryujinx.Audio/Renderer/Dsp/FloatingPointHelper.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Audio.Renderer.Dsp
@@ -46,6 +47,53 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return MathF.Pow(10, x);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Log10(float x)
+        {
+            // NOTE: Nintendo uses an approximation of log10, we don't.
+            // As such, we support the same ranges as Nintendo to avoid unexpected behaviours.
+            return MathF.Pow(10, MathF.Max(x, 1.0e-10f));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float MeanSquare(ReadOnlySpan<float> inputs)
+        {
+            float res = 0.0f;
+
+            foreach (float input in inputs)
+            {
+                res += (input * input);
+            }
+
+            res /= inputs.Length;
+
+            return res;
+        }
+
+        /// <summary>
+        /// Map decibel to linear.
+        /// </summary>
+        /// <param name="db">The decibel value to convert</param>
+        /// <returns>Converted linear value/returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float DecibelToLinear(float db)
+        {
+            return MathF.Pow(10.0f, db / 20.0f);
+        }
+
+        /// <summary>
+        /// Map decibel to linear in [0, 2] range.
+        /// </summary>
+        /// <param name="db">The decibel value to convert</param>
+        /// <returns>Converted linear value in [0, 2] range</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float DecibelToLinearExtended(float db)
+        {
+            float tmp = MathF.Log2(DecibelToLinear(db));
+
+            return MathF.Truncate(tmp) + MathF.Pow(2.0f, tmp - MathF.Truncate(tmp));
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float DegreesToRadians(float degrees)
         {

Ryujinx.Audio/Renderer/Dsp/State/CompressorState.cs

@@ -0,0 +1,51 @@
+using Ryujinx.Audio.Renderer.Dsp.Effect;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+
+namespace Ryujinx.Audio.Renderer.Dsp.State
+{
+    public class CompressorState
+    {
+        public ExponentialMovingAverage InputMovingAverage;
+        public float Unknown4;
+        public ExponentialMovingAverage CompressionGainAverage;
+        public float CompressorGainReduction;
+        public float Unknown10;
+        public float Unknown14;
+        public float PreviousCompressionEmaAlpha;
+        public float MakeupGain;
+        public float OutputGain;
+
+        public CompressorState(ref CompressorParameter parameter)
+        {
+            InputMovingAverage = new ExponentialMovingAverage(0.0f);
+            Unknown4 = 1.0f;
+            CompressionGainAverage = new ExponentialMovingAverage(1.0f);
+
+            UpdateParameter(ref parameter);
+        }
+
+        public void UpdateParameter(ref CompressorParameter parameter)
+        {
+            float threshold = parameter.Threshold;
+            float ratio = 1.0f / parameter.Ratio;
+            float attackCoefficient = parameter.AttackCoefficient;
+            float makeupGain;
+
+            if (parameter.MakeupGainEnabled)
+            {
+                makeupGain = (threshold * 0.5f * (ratio - 1.0f)) - 3.0f;
+            }
+            else
+            {
+                makeupGain = 0.0f;
+            }
+
+            PreviousCompressionEmaAlpha = attackCoefficient;
+            MakeupGain = makeupGain;
+            CompressorGainReduction = (1.0f - ratio) / Constants.ChannelCountMax;
+            Unknown10 = threshold - 1.5f;
+            Unknown14 = threshold + 1.5f;
+            OutputGain = FloatingPointHelper.DecibelToLinearExtended(parameter.OutputGain + makeupGain);
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/State/LimiterState.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Audio.Renderer.Dsp.Effect;
 using Ryujinx.Audio.Renderer.Parameter.Effect;
 using System;
 
@@ -5,20 +6,20 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
 {
     public class LimiterState
     {
-        public float[] DectectorAverage;
-        public float[] CompressionGain;
+        public ExponentialMovingAverage[] DetectorAverage;
+        public ExponentialMovingAverage[] CompressionGainAverage;
         public float[] DelayedSampleBuffer;
         public int[] DelayedSampleBufferPosition;
 
         public LimiterState(ref LimiterParameter parameter, ulong workBuffer)
         {
-            DectectorAverage = new float[parameter.ChannelCount];
-            CompressionGain = new float[parameter.ChannelCount];
+            DetectorAverage = new ExponentialMovingAverage[parameter.ChannelCount];
+            CompressionGainAverage = new ExponentialMovingAverage[parameter.ChannelCount];
             DelayedSampleBuffer = new float[parameter.ChannelCount * parameter.DelayBufferSampleCountMax];
             DelayedSampleBufferPosition = new int[parameter.ChannelCount];
 
-            DectectorAverage.AsSpan().Fill(0.0f);
-            CompressionGain.AsSpan().Fill(1.0f);
+            DetectorAverage.AsSpan().Fill(new ExponentialMovingAverage(0.0f));
+            CompressionGainAverage.AsSpan().Fill(new ExponentialMovingAverage(1.0f));
             DelayedSampleBufferPosition.AsSpan().Fill(0);
             DelayedSampleBuffer.AsSpan().Fill(0.0f);
 

Ryujinx.Audio/Renderer/Parameter/Effect/CompressorParameter.cs

@@ -0,0 +1,115 @@
+using Ryujinx.Audio.Renderer.Server.Effect;
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Parameter.Effect
+{
+    /// <summary>
+    /// <see cref="IEffectInParameter.SpecificData"/> for <see cref="Common.EffectType.Compressor"/>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct CompressorParameter
+    {
+        /// <summary>
+        /// The input channel indices that will be used by the <see cref="Dsp.AudioProcessor"/>.
+        /// </summary>
+        public Array6<byte> Input;
+
+        /// <summary>
+        /// The output channel indices that will be used by the <see cref="Dsp.AudioProcessor"/>.
+        /// </summary>
+        public Array6<byte> Output;
+
+        /// <summary>
+        /// The maximum number of channels supported.
+        /// </summary>
+        public ushort ChannelCountMax;
+
+        /// <summary>
+        /// The total channel count used.
+        /// </summary>
+        public ushort ChannelCount;
+
+        /// <summary>
+        /// The target sample rate.
+        /// </summary>
+        /// <remarks>This is in kHz.</remarks>
+        public int SampleRate;
+
+        /// <summary>
+        /// The threshold.
+        /// </summary>
+        public float Threshold;
+
+        /// <summary>
+        /// The compressor ratio.
+        /// </summary>
+        public float Ratio;
+
+        /// <summary>
+        /// The attack time.
+        /// <remarks>This is in microseconds.</remarks>
+        /// </summary>
+        public int AttackTime;
+
+        /// <summary>
+        /// The release time.
+        /// <remarks>This is in microseconds.</remarks>
+        /// </summary>
+        public int ReleaseTime;
+
+        /// <summary>
+        /// The input gain.
+        /// </summary>
+        public float InputGain;
+
+        /// <summary>
+        /// The attack coefficient.
+        /// </summary>
+        public float AttackCoefficient;
+
+        /// <summary>
+        /// The release coefficient.
+        /// </summary>
+        public float ReleaseCoefficient;
+
+        /// <summary>
+        /// The output gain.
+        /// </summary>
+        public float OutputGain;
+
+        /// <summary>
+        /// The current usage status of the effect on the client side.
+        /// </summary>
+        public UsageState Status;
+
+        /// <summary>
+        /// Indicate if the makeup gain should be used.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool MakeupGainEnabled;
+
+        /// <summary>
+        /// Reserved/padding.
+        /// </summary>
+        private Array2<byte> _reserved;
+
+        /// <summary>
+        /// Check if the <see cref="ChannelCount"/> is valid.
+        /// </summary>
+        /// <returns>Returns true if the <see cref="ChannelCount"/> is valid.</returns>
+        public bool IsChannelCountValid()
+        {
+            return EffectInParameterVersion1.IsChannelCountValid(ChannelCount);
+        }
+
+        /// <summary>
+        /// Check if the <see cref="ChannelCountMax"/> is valid.
+        /// </summary>
+        /// <returns>Returns true if the <see cref="ChannelCountMax"/> is valid.</returns>
+        public bool IsChannelCountMaxValid()
+        {
+            return EffectInParameterVersion1.IsChannelCountValid(ChannelCountMax);
+        }
+    }
+}

Ryujinx.Audio/Renderer/Server/BehaviourContext.cs

@@ -44,7 +44,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <see cref="Parameter.RendererInfoOutStatus"/> was added to supply the count of update done sent to the DSP.
         /// A new version of the command estimator was added to address timing changes caused by the voice changes.
         /// Additionally, the rendering limit percent was incremented to 80%.
-        /// 
+        ///
         /// </summary>
         /// <remarks>This was added in system update 6.0.0</remarks>
         public const int Revision5 = 5 << 24;
@@ -93,6 +93,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <summary>
         /// REV11:
         /// The "legacy" effects (Delay, Reverb and Reverb 3D) were updated to match the standard channel mapping used by the audio renderer.
+        /// A new effect was added: Compressor. This effect is effectively implemented with a DRC.
         /// A new version of the command estimator was added to address timing changes caused by the legacy effects changes.
         /// A voice drop parameter was added in 15.0.0: This allows an application to amplify or attenuate the estimated time of DSP commands.
         /// </summary>

Ryujinx.Audio/Renderer/Server/CommandBuffer.cs

@@ -469,6 +469,18 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
+        public void GenerateCompressorEffect(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        {
+            if (parameter.IsChannelCountValid())
+            {
+                CompressorCommand command = new CompressorCommand(bufferOffset, parameter, state, isEnabled, nodeId);
+
+                command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
+
+                AddCommand(command);
+            }
+        }
+
         /// <summary>
         /// Generate a new <see cref="VolumeCommand"/>.
         /// </summary>

Ryujinx.Audio/Renderer/Server/CommandGenerator.cs

@@ -606,6 +606,17 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
+        private void GenerateCompressorEffect(uint bufferOffset, CompressorEffect effect, int nodeId)
+        {
+            Debug.Assert(effect.Type == EffectType.Compressor);
+
+            _commandBuffer.GenerateCompressorEffect(bufferOffset,
+                                                    effect.Parameter,
+                                                    effect.State,
+                                                    effect.IsEnabled,
+                                                    nodeId);
+        }
+
         private void GenerateEffect(ref MixState mix, int effectId, BaseEffect effect)
         {
             int nodeId = mix.NodeId;
@@ -650,6 +661,9 @@ namespace Ryujinx.Audio.Renderer.Server
                 case EffectType.CaptureBuffer:
                     GenerateCaptureEffect(mix.BufferOffset, (CaptureBufferEffect)effect, nodeId);
                     break;
+                case EffectType.Compressor:
+                    GenerateCompressorEffect(mix.BufferOffset, (CompressorEffect)effect, nodeId);
+                    break;
                 default:
                     throw new NotImplementedException($"Unsupported effect type {effect.Type}");
             }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion1.cs

@@ -179,5 +179,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion2.cs

@@ -543,5 +543,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion3.cs

@@ -747,5 +747,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public virtual uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion5.cs

@@ -232,5 +232,79 @@ namespace Ryujinx.Audio.Renderer.Server
                 }
             }
         }
+
+        public override uint Estimate(CompressorCommand command)
+        {
+            Debug.Assert(_sampleCount == 160 || _sampleCount == 240);
+
+            if (_sampleCount == 160)
+            {
+                if (command.Enabled)
+                {
+                    switch (command.Parameter.ChannelCount)
+                    {
+                        case 1:
+                            return 34431;
+                        case 2:
+                            return 44253;
+                        case 4:
+                            return 63827;
+                        case 6:
+                            return 83361;
+                        default:
+                            throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                    }
+                }
+                else
+                {
+                    switch (command.Parameter.ChannelCount)
+                    {
+                        case 1:
+                            return (uint)630.12f;
+                        case 2:
+                            return (uint)638.27f;
+                        case 4:
+                            return (uint)705.86f;
+                        case 6:
+                            return (uint)782.02f;
+                        default:
+                            throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                    }
+                }
+            }
+
+            if (command.Enabled)
+            {
+                switch (command.Parameter.ChannelCount)
+                {
+                    case 1:
+                        return 51095;
+                    case 2:
+                        return 65693;
+                    case 4:
+                        return 95383;
+                    case 6:
+                        return 124510;
+                    default:
+                        throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                }
+            }
+            else
+            {
+                switch (command.Parameter.ChannelCount)
+                {
+                    case 1:
+                        return (uint)840.14f;
+                    case 2:
+                        return (uint)826.1f;
+                    case 4:
+                        return (uint)901.88f;
+                    case 6:
+                        return (uint)965.29f;
+                    default:
+                        throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                }
+            }
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs

@@ -262,6 +262,8 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
                     return PerformanceDetailType.Limiter;
                 case EffectType.CaptureBuffer:
                     return PerformanceDetailType.CaptureBuffer;
+                case EffectType.Compressor:
+                    return PerformanceDetailType.Compressor;
                 default:
                     throw new NotImplementedException($"{Type}");
             }

Ryujinx.Audio/Renderer/Server/Effect/CompressorEffect.cs

@@ -0,0 +1,67 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a compressor effect.
+    /// </summary>
+    public class CompressorEffect : BaseEffect
+    {
+        /// <summary>
+        /// The compressor parameter.
+        /// </summary>
+        public CompressorParameter Parameter;
+
+        /// <summary>
+        /// The compressor state.
+        /// </summary>
+        public Memory<CompressorState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="CompressorEffect"/>.
+        /// </summary>
+        public CompressorEffect()
+        {
+            State = new CompressorState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Compressor;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            // Nintendo doesn't do anything here but we still require updateErrorInfo to be initialised.
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, CompressorParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}

Ryujinx.Audio/Renderer/Server/ICommandProcessingTimeEstimator.cs

@@ -35,5 +35,6 @@ namespace Ryujinx.Audio.Renderer.Server
         uint Estimate(LimiterCommandVersion2 command);
         uint Estimate(GroupedBiquadFilterCommand command);
         uint Estimate(CaptureBufferCommand command);
+        uint Estimate(CompressorCommand command);
     }
 }

Ryujinx.Audio/Renderer/Server/StateUpdater.cs

@@ -240,6 +240,10 @@ namespace Ryujinx.Audio.Renderer.Server
                 case EffectType.CaptureBuffer:
                     effect = new CaptureBufferEffect();
                     break;
+                case EffectType.Compressor:
+                    effect = new CompressorEffect();
+                    break;
+
                 default:
                     throw new NotImplementedException($"EffectType {parameter.Type} not implemented!");
             }

Ryujinx.Ava/AppHost.cs

@@ -125,7 +125,7 @@ namespace Ryujinx.Ava
             _inputManager = inputManager;
             _accountManager = accountManager;
             _userChannelPersistence = userChannelPersistence;
-            _renderingThread = new Thread(RenderLoop) { Name = "GUI.RenderThread" };
+            _renderingThread = new Thread(RenderLoop, 1 * 1024 * 1024) { Name = "GUI.RenderThread" };
             _hideCursorOnIdle = ConfigurationState.Instance.HideCursorOnIdle;
             _lastCursorMoveTime = Stopwatch.GetTimestamp();
             _glLogLevel = ConfigurationState.Instance.Logger.GraphicsDebugLevel;

Ryujinx.Ava/Assets/Locales/de_DE.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Aktiviere Fs Zugriff-Logs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Globaler Zugriff-Log-Modus:",
   "SettingsTabLoggingDeveloperOptions": "Entwickleroptionen (WARNUNG: Beeinträchtigt die Leistung)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Logstufe:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Keine",
-  "SettingsTabLoggingOpenglLogLevelError": "Fehler",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Verlangsamungen",
-  "SettingsTabLoggingOpenglLogLevelAll": "Alle",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Keine",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Fehler",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Verlangsamungen",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Alle",
   "SettingsTabLoggingEnableDebugLogs": "Aktiviere Debug-Log",
   "SettingsTabInput": "Eingabe",
   "SettingsTabInputEnableDockedMode": "Docked Modus",

Ryujinx.Ava/Assets/Locales/el_GR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Ενεργοποίηση Καταγραφής Πρόσβασης FS",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Λειτουργία Καταγραφής Καθολικής Πρόσβασης FS:",
   "SettingsTabLoggingDeveloperOptions": "Επιλογές Προγραμματιστή (ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Η απόδοση Θα μειωθεί)",
-  "SettingsTabLoggingOpenglLogLevel": "Επίπεδο Καταγραφής OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Κανένα",
-  "SettingsTabLoggingOpenglLogLevelError": "Σφάλμα",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Επιβραδύνσεις",
-  "SettingsTabLoggingOpenglLogLevelAll": "Όλα",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Κανένα",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Σφάλμα",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Επιβραδύνσεις",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Όλα",
   "SettingsTabLoggingEnableDebugLogs": "Ενεργοποίηση Αρχείων Καταγραφής Εντοπισμού Σφαλμάτων",
   "SettingsTabInput": "Χειρισμός",
   "SettingsTabInputEnableDockedMode": "Ενεργοποίηση Docked Mode",

Ryujinx.Ava/Assets/Locales/en_US.json

@@ -157,11 +157,11 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Enable Fs Access Logs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Global Access Log Mode:",
   "SettingsTabLoggingDeveloperOptions": "Developer Options (WARNING: Will reduce performance)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Log Level:",
-  "SettingsTabLoggingOpenglLogLevelNone": "None",
-  "SettingsTabLoggingOpenglLogLevelError": "Error",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Slowdowns",
-  "SettingsTabLoggingOpenglLogLevelAll": "All",
+  "SettingsTabLoggingGraphicsBackendLogLevel": "Graphics Backend Log Level:",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "None",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Error",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Slowdowns",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "All",
   "SettingsTabLoggingEnableDebugLogs": "Enable Debug Logs",
   "SettingsTabInput": "Input",
   "SettingsTabInputEnableDockedMode": "Docked Mode",
@@ -315,7 +315,7 @@
   "DialogUpdaterConvertFailedMessage": "Failed to convert the current Ryujinx version.",
   "DialogUpdaterCancelUpdateMessage": "Cancelling Update!",
   "DialogUpdaterAlreadyOnLatestVersionMessage": "You are already using the most updated version of Ryujinx!",
-  "DialogUpdaterFailedToGetVersionMessage": "An error has occurred when trying to get release information from Github Release. This can be caused if a new release is being compiled by GitHub Actions. Try again in a few minutes.",
+  "DialogUpdaterFailedToGetVersionMessage": "An error has occurred when trying to get release information from GitHub Release. This can be caused if a new release is being compiled by GitHub Actions. Try again in a few minutes.",
   "DialogUpdaterConvertFailedGithubMessage": "Failed to convert the received Ryujinx version from Github Release.",
   "DialogUpdaterDownloadingMessage": "Downloading Update...",
   "DialogUpdaterExtractionMessage": "Extracting Update...",
@@ -596,7 +596,18 @@
   "RyujinxUpdaterMessage": "Do you want to update Ryujinx to the latest version?",
   "SettingsTabHotkeysVolumeUpHotkey": "Increase Volume:",
   "SettingsTabHotkeysVolumeDownHotkey": "Decrease Volume:",
-  "VolumeShort": "Vol",
   "SettingsEnableMacroHLE": "Enable Macro HLE",
-  "SettingsEnableMacroHLETooltip": "High-level emulation of GPU Macro code.\n\nImproves performance, but may cause graphical glitches in some games.\n\nLeave ON if unsure."
+  "SettingsEnableMacroHLETooltip": "High-level emulation of GPU Macro code.\n\nImproves performance, but may cause graphical glitches in some games.\n\nLeave ON if unsure.",
+  "VolumeShort": "Vol",
+  "UserProfilesManageSaves": "Manage Saves",
+  "DeleteUserSave": "Do you want to delete user save for this game?",
+  "IrreversibleActionNote": "This action is not reversible.",
+  "SaveManagerHeading": "Manage Saves for {0}",
+  "SaveManagerTitle": "Save Manager",
+  "Name": "Name",
+  "Size": "Size",
+  "Search": "Search",
+  "UserProfilesRecoverLostAccounts": "Recover Lost Accounts",
+  "Recover": "Recover",
+  "UserProfilesRecoverHeading" : "Saves were found for the following accounts"
 }

Ryujinx.Ava/Assets/Locales/es_ES.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Habilitar registros de Fs Access",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Modo de registros Fs Global Access:",
   "SettingsTabLoggingDeveloperOptions": "Opciones de desarrollador (ADVERTENCIA: empeorarán el rendimiento)",
-  "SettingsTabLoggingOpenglLogLevel": "Nivel de registro de OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Nada",
-  "SettingsTabLoggingOpenglLogLevelError": "Errores",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Ralentizaciones",
-  "SettingsTabLoggingOpenglLogLevelAll": "Todo",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nada",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Errores",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Ralentizaciones",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Todo",
   "SettingsTabLoggingEnableDebugLogs": "Habilitar registros de debug",
   "SettingsTabInput": "Entrada",
   "SettingsTabInputEnableDockedMode": "Modo dock/TV",

Ryujinx.Ava/Assets/Locales/fr_FR.json

@@ -150,11 +150,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Activer les journaux des accès au système de fichiers",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Niveau des journaux des accès au système de fichiers:",
   "SettingsTabLoggingDeveloperOptions": "Options développeur (ATTENTION: Cela peut réduire les performances)",
-  "SettingsTabLoggingOpenglLogLevel": "Niveau des journaux OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Aucun",
-  "SettingsTabLoggingOpenglLogLevelError": "Erreur",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Ralentissements",
-  "SettingsTabLoggingOpenglLogLevelAll": "Tout",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Aucun",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Erreur",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Ralentissements",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Tout",
   "SettingsTabLoggingEnableDebugLogs": "Activer les journaux de debug",
   "SettingsTabInput": "Contrôles",
   "SettingsTabInputEnableDockedMode": "Active le mode station d'accueil",

Ryujinx.Ava/Assets/Locales/it_IT.json

@@ -157,11 +157,10 @@
     "SettingsTabLoggingEnableFsAccessLogs": "Attiva Fs Access Logs",
     "SettingsTabLoggingFsGlobalAccessLogMode": "Modalità log accesso globale Fs:",
     "SettingsTabLoggingDeveloperOptions": "Opzioni da sviluppatore (AVVISO: Ridurrà le prestazioni)",
-    "SettingsTabLoggingOpenglLogLevel": "Livello di log OpenGL:",
-    "SettingsTabLoggingOpenglLogLevelNone": "Nessuno",
-    "SettingsTabLoggingOpenglLogLevelError": "Errore",
-    "SettingsTabLoggingOpenglLogLevelPerformance": "Rallentamenti",
-    "SettingsTabLoggingOpenglLogLevelAll": "Tutto",
+    "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nessuno",
+    "SettingsTabLoggingGraphicsBackendLogLevelError": "Errore",
+    "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Rallentamenti",
+    "SettingsTabLoggingGraphicsBackendLogLevelAll": "Tutto",
     "SettingsTabLoggingEnableDebugLogs": "Attiva logs di debug",
     "SettingsTabInput": "Input",
     "SettingsTabInputEnableDockedMode": "Attiva modalità TV",
@@ -558,8 +557,8 @@
     "SettingsSelectThemeFileDialogTitle" : "Seleziona file del tema",
     "SettingsXamlThemeFile" : "File del tema xaml",
     "SettingsTabHotkeysResScaleUpHotkey": "Aumentare la risoluzione:",
-    "SettingsTabHotkeysResScaleDownHotkey": "Diminuire la risoluzione:"
-    "AvatarWindowTitle": "Gestisci account - Avatar"
+    "SettingsTabHotkeysResScaleDownHotkey": "Diminuire la risoluzione:",
+    "AvatarWindowTitle": "Gestisci account - Avatar",
     "Amiibo": "Amiibo",
     "Unknown": "Sconosciuto",
     "Usage": "Utilizzo",

Ryujinx.Ava/Assets/Locales/ja_JP.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs アクセスログを有効",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs グローバルアクセスログモード:",
   "SettingsTabLoggingDeveloperOptions": "開発者オプション (警告: パフォーマンスが低下します)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL ログレベル:",
-  "SettingsTabLoggingOpenglLogLevelNone": "なし",
-  "SettingsTabLoggingOpenglLogLevelError": "エラー",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "パフォーマンス低下",
-  "SettingsTabLoggingOpenglLogLevelAll": "すべて",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "なし",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "エラー",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "パフォーマンス低下",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "すべて",
   "SettingsTabLoggingEnableDebugLogs": "デバッグログを有効",
   "SettingsTabInput": "入力",
   "SettingsTabInputEnableDockedMode": "ドッキングモード",

Ryujinx.Ava/Assets/Locales/ko_KR.json

@@ -156,11 +156,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs 액세스 로그 켜기",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs 전역 액세스 로그 모드 :",
   "SettingsTabLoggingDeveloperOptions": "개발자 옵션 (경고 : 성능이 저하됩니다.)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL 로그 수준 :",
-  "SettingsTabLoggingOpenglLogLevelNone": "없음",
-  "SettingsTabLoggingOpenglLogLevelError": "오류",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "감속",
-  "SettingsTabLoggingOpenglLogLevelAll": "모두",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "없음",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "오류",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "감속",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "모두",
   "SettingsTabLoggingEnableDebugLogs": "디버그 로그 사용",
   "SettingsTabInput": "입력",
   "SettingsTabInputEnableDockedMode": "도킹 모드 활성화",

Ryujinx.Ava/Assets/Locales/pl_PL.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Włącz Logi Dostępu do Systemu Plików",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Tryb Globalnych Logów Systemu Plików:",
   "SettingsTabLoggingDeveloperOptions": "Opcje programistyczne (OSTRZEŻENIE: Zmniejszą wydajność)",
-  "SettingsTabLoggingOpenglLogLevel": "Poziom Logów OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Żadne",
-  "SettingsTabLoggingOpenglLogLevelError": "Błędy",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Spowolnienia",
-  "SettingsTabLoggingOpenglLogLevelAll": "Wszystkie",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Żadne",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Błędy",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Spowolnienia",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Wszystkie",
   "SettingsTabLoggingEnableDebugLogs": "Włącz Logi Debugowania",
   "SettingsTabInput": "Sterowanie",
   "SettingsTabInputEnableDockedMode": "Tryb Zadokowany",

Ryujinx.Ava/Assets/Locales/pt_BR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Habilitar logs de acesso ao sistema de arquivos",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Modo global de logs do sistema de arquivos:",
   "SettingsTabLoggingDeveloperOptions": "Opções do desenvolvedor (AVISO: Vai reduzir a performance)",
-  "SettingsTabLoggingOpenglLogLevel": "Nível de log do OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Nenhum",
-  "SettingsTabLoggingOpenglLogLevelError": "Erro",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Lentidão",
-  "SettingsTabLoggingOpenglLogLevelAll": "Todos",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nenhum",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Erro",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Lentidão",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Todos",
   "SettingsTabLoggingEnableDebugLogs": "Habilitar logs de depuração",
   "SettingsTabInput": "Controle",
   "SettingsTabInputEnableDockedMode": "Habilitar modo TV",

Ryujinx.Ava/Assets/Locales/ru_RU.json

@@ -156,11 +156,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Включить журналы доступа Fs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Режим журнала глобального доступа Fs:",
   "SettingsTabLoggingDeveloperOptions": "Параметры разработчика (ВНИМАНИЕ: снизит производительность)",
-  "SettingsTabLoggingOpenglLogLevel": "Уровень журнала OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Ничего",
-  "SettingsTabLoggingOpenglLogLevelError": "Ошибка",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Замедления",
-  "SettingsTabLoggingOpenglLogLevelAll": "Всё",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Ничего",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Ошибка",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Замедления",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Всё",
   "SettingsTabLoggingEnableDebugLogs": "Включить журналы отладки",
   "SettingsTabInput": "Управление",
   "SettingsTabInputEnableDockedMode": "Включить режим закрепления",

Ryujinx.Ava/Assets/Locales/tr_TR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs Erişim Loglarını Etkinleştir",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Evrensel Erişim Log Modu:",
   "SettingsTabLoggingDeveloperOptions": "Geliştirici Seçenekleri (UYARI: Performansı düşürecektir)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Log Seviyesi:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Hiç",
-  "SettingsTabLoggingOpenglLogLevelError": "Hata",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Yavaşlamalar",
-  "SettingsTabLoggingOpenglLogLevelAll": "Her Şey",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Hiç",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Hata",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Yavaşlamalar",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Her Şey",
   "SettingsTabLoggingEnableDebugLogs": "Hata Ayıklama Loglarını Etkinleştir",
   "SettingsTabInput": "Giriş Yöntemi",
   "SettingsTabInputEnableDockedMode": "Docked Modunu Etkinleştir",

Ryujinx.Ava/Assets/Locales/zh_CN.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "记录文件访问",
   "SettingsTabLoggingFsGlobalAccessLogMode": "记录全局文件访问模式:",
   "SettingsTabLoggingDeveloperOptions": "开发者选项 (警告: 会降低性能)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL日志级别:",
-  "SettingsTabLoggingOpenglLogLevelNone": "无",
-  "SettingsTabLoggingOpenglLogLevelError": "错误",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "减速",
-  "SettingsTabLoggingOpenglLogLevelAll": "全部",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "无",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "错误",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "减速",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "全部",
   "SettingsTabLoggingEnableDebugLogs": "启用调试日志",
   "SettingsTabInput": "输入",
   "SettingsTabInputEnableDockedMode": "主机模式",

Ryujinx.Ava/Assets/Locales/zh_TW.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "記錄檔案存取",
   "SettingsTabLoggingFsGlobalAccessLogMode": "記錄全域檔案存取模式:",
   "SettingsTabLoggingDeveloperOptions": "開發者選項 (警告: 會降低效能)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL 日誌級別:",
-  "SettingsTabLoggingOpenglLogLevelNone": "無",
-  "SettingsTabLoggingOpenglLogLevelError": "錯誤",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "減速",
-  "SettingsTabLoggingOpenglLogLevelAll": "全部",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "無",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "錯誤",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "減速",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "全部",
   "SettingsTabLoggingEnableDebugLogs": "啟用除錯日誌",
   "SettingsTabInput": "輸入",
   "SettingsTabInputEnableDockedMode": "Docked 模式",

Ryujinx.Ava/Assets/Styles/BaseDark.xaml

@@ -41,6 +41,9 @@
         <SolidColorBrush x:Key="DataGridSelectionBackgroundBrush" Color="{DynamicResource DataGridSelectionColor}" />
         <SolidColorBrush x:Key="ThemeAccentColorBrush" Color="{DynamicResource SystemAccentColor}" />
         <SolidColorBrush x:Key="ThemeAccentBrush4" Color="{DynamicResource ThemeAccentColor4}" />
+        <Color x:Key="ControlFillColorSecondary">#008AA8</Color>
+        <SolidColorBrush x:Key="ControlFillColorSecondaryBrush" Color="{StaticResource ControlFillColorSecondary}" />
+        <StaticResource x:Key="ButtonBackgroundPointerOver" ResourceKey="ControlFillColorSecondaryBrush" />
         <Color x:Key="SystemAccentColor">#FF00C3E3</Color>
         <Color x:Key="SystemAccentColorDark1">#FF99b000</Color>
         <Color x:Key="SystemAccentColorDark2">#FF006d7d</Color>
@@ -55,5 +58,7 @@
         <Color x:Key="SystemChromeWhiteColor">#FFFFFFFF</Color>
         <Color x:Key="ThemeForegroundColor">#FFFFFFFF</Color>
         <Color x:Key="MenuFlyoutPresenterBorderColor">#3D3D3D</Color>
+        <Color x:Key="AppListBackgroundColor">#0FFFFFFF</Color>
+        <Color x:Key="AppListHoverBackgroundColor">#1EFFFFFF</Color>
     </Styles.Resources>
 </Styles>

Ryujinx.Ava/Assets/Styles/BaseLight.xaml

@@ -50,5 +50,7 @@
         <Color x:Key="SystemChromeWhiteColor">#FFFFFFFF</Color>
         <Color x:Key="ThemeForegroundColor">#FF000000</Color>
         <Color x:Key="MenuFlyoutPresenterBorderColor">#C1C1C1</Color>
+        <Color x:Key="AppListBackgroundColor">#b3ffffff</Color>
+        <Color x:Key="AppListHoverBackgroundColor">#80cccccc</Color>
     </Styles.Resources>
 </Styles>

Ryujinx.Ava/Assets/Styles/Styles.xaml

@@ -1,7 +1,6 @@
 <Styles
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:sys="clr-namespace:System;assembly=netstandard"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia">
     <Design.PreviewWith>
         <Border Height="2000" Padding="20">
@@ -162,6 +161,7 @@
     <Style Selector="MenuItem">
         <Setter Property="Height" Value="{DynamicResource MenuItemHeight}" />
         <Setter Property="Padding" Value="{DynamicResource MenuItemPadding}" />
+        <Setter Property="FontSize" Value="12" />
     </Style>
     <Style Selector="MenuItem:selected /template/ Border#root">
         <Setter Property="Background" Value="{DynamicResource ThemeControlBorderColor}" />
@@ -269,13 +269,15 @@
         <Color x:Key="DataGridSelectionColor">#FF00FABB</Color>
         <Color x:Key="ThemeContentBackgroundColor">#FF2D2D2D</Color>
         <Color x:Key="ThemeControlBorderColor">#FF505050</Color>
-        <sys:Double x:Key="ScrollBarThickness">15</sys:Double>
-        <sys:Double x:Key="FontSizeSmall">8</sys:Double>
-        <sys:Double x:Key="FontSizeNormal">10</sys:Double>
-        <sys:Double x:Key="FontSize">12</sys:Double>
-        <sys:Double x:Key="FontSizeLarge">15</sys:Double>
-        <sys:Double x:Key="ControlContentThemeFontSize">13</sys:Double>
+        <x:Double x:Key="ScrollBarThickness">15</x:Double>
+        <x:Double x:Key="FontSizeSmall">8</x:Double>
+        <x:Double x:Key="FontSizeNormal">10</x:Double>
+        <x:Double x:Key="FontSize">12</x:Double>
+        <x:Double x:Key="FontSizeLarge">15</x:Double>
+        <x:Double x:Key="ControlContentThemeFontSize">13</x:Double>
         <x:Double x:Key="MenuItemHeight">26</x:Double>
         <x:Double x:Key="TabItemMinHeight">28</x:Double>
+        <x:Double x:Key="ContentDialogMaxWidth">600</x:Double>
+        <x:Double x:Key="ContentDialogMaxHeight">756</x:Double>
     </Styles.Resources>
 </Styles>

Ryujinx.Ava/Common/ApplicationHelper.cs

@@ -113,6 +113,11 @@ namespace Ryujinx.Ava.Common
                 return;
             }
 
+            OpenSaveDir(saveDataId);
+        }
+
+        public static void OpenSaveDir(ulong saveDataId)
+        {
             string saveRootPath = Path.Combine(_virtualFileSystem.GetNandPath(), $"user/save/{saveDataId:x16}");
 
             if (!Directory.Exists(saveRootPath))

Ryujinx.Ava/Helper/MetalHelper.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
+using Avalonia;
+
+namespace Ryujinx.Ava.Ui.Helper
+{
+    public delegate void UpdateBoundsCallbackDelegate(Rect rect);
+
+    [SupportedOSPlatform("macos")]
+    static class MetalHelper
+    {
+        private const string LibObjCImport = "/usr/lib/libobjc.A.dylib";
+
+        private struct Selector
+        {
+            public readonly IntPtr NativePtr;
+
+            public unsafe Selector(string value)
+            {
+                int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+                byte* data = stackalloc byte[size];
+
+                fixed (char* pValue = value)
+                {
+                    System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+                }
+
+                NativePtr = sel_registerName(data);
+            }
+
+            public static implicit operator Selector(string value) => new Selector(value);
+        }
+
+        private static unsafe IntPtr GetClass(string value)
+        {
+            int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+            byte* data = stackalloc byte[size];
+
+            fixed (char* pValue = value)
+            {
+                System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+            }
+
+            return objc_getClass(data);
+        }
+
+        private struct NSPoint
+        {
+            public double X;
+            public double Y;
+
+            public NSPoint(double x, double y)
+            {
+                X = x;
+                Y = y;
+            }
+        }
+
+        private struct NSRect
+        {
+            public NSPoint Pos;
+            public NSPoint Size;
+
+            public NSRect(double x, double y, double width, double height)
+            {
+                Pos = new NSPoint(x, y);
+                Size = new NSPoint(width, height);
+            }
+        }
+
+        public static IntPtr GetMetalLayer(out IntPtr nsView, out UpdateBoundsCallbackDelegate updateBounds)
+        {
+            // Create a new CAMetalLayer.
+            IntPtr layerClass = GetClass("CAMetalLayer");
+            IntPtr metalLayer = IntPtr_objc_msgSend(layerClass, "alloc");
+            objc_msgSend(metalLayer, "init");
+
+            // Create a child NSView to render into.
+            IntPtr nsViewClass = GetClass("NSView");
+            IntPtr child = IntPtr_objc_msgSend(nsViewClass, "alloc");
+            objc_msgSend(child, "init", new NSRect(0, 0, 0, 0));
+
+            // Make its renderer our metal layer.
+            objc_msgSend(child, "setWantsLayer:", (byte)1);
+            objc_msgSend(child, "setLayer:", metalLayer);
+            objc_msgSend(metalLayer, "setContentsScale:", Program.DesktopScaleFactor);
+
+            // Ensure the scale factor is up to date.
+            updateBounds = (Rect rect) => {
+                objc_msgSend(metalLayer, "setContentsScale:", Program.DesktopScaleFactor);
+            };
+
+            nsView = child;
+            return metalLayer;
+        }
+
+        public static void DestroyMetalLayer(IntPtr nsView, IntPtr metalLayer)
+        {
+            // TODO
+        }
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr sel_registerName(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr objc_getClass(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, byte value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, IntPtr value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, NSRect point);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, double value);
+
+        [DllImport(LibObjCImport, EntryPoint = "objc_msgSend")]
+        private static extern IntPtr IntPtr_objc_msgSend(IntPtr receiver, Selector selector);
+    }
+}

Ryujinx.Ava/Input/AvaloniaKeyboard.cs

@@ -4,7 +4,6 @@ using Ryujinx.Input;
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-
 using ConfigKey = Ryujinx.Common.Configuration.Hid.Key;
 using Key = Ryujinx.Input.Key;
 
@@ -13,30 +12,37 @@ namespace Ryujinx.Ava.Input
     internal class AvaloniaKeyboard : IKeyboard
     {
         private readonly List<ButtonMappingEntry> _buttonsUserMapping;
-        private readonly AvaloniaKeyboardDriver _driver;
+        private readonly AvaloniaKeyboardDriver   _driver;
+        private StandardKeyboardInputConfig       _configuration;
 
         private readonly object _userMappingLock = new();
 
-        private StandardKeyboardInputConfig _configuration;
-
-        private bool HasConfiguration => _configuration != null;
-
-        public string Id { get; }
+        public string Id   { get; }
         public string Name { get; }
 
-        public bool IsConnected => true;
+        public bool                IsConnected => true;
+        public GamepadFeaturesFlag Features    => GamepadFeaturesFlag.None;
 
-        public GamepadFeaturesFlag Features => GamepadFeaturesFlag.None;
+        private class ButtonMappingEntry
+        {
+            public readonly Key                  From;
+            public readonly GamepadButtonInputId To;
+
+            public ButtonMappingEntry(GamepadButtonInputId to, Key from)
+            {
+                To   = to;
+                From = from;
+            }
+        }
 
         public AvaloniaKeyboard(AvaloniaKeyboardDriver driver, string id, string name)
         {
-            _driver = driver;
-            Id = id;
-            Name = name;
             _buttonsUserMapping = new List<ButtonMappingEntry>();
-        }
 
-        public void Dispose() { }
+            _driver = driver;
+            Id      = id;
+            Name    = name;
+        }
 
         public KeyboardStateSnapshot GetKeyboardStateSnapshot()
         {
@@ -46,11 +52,11 @@ namespace Ryujinx.Ava.Input
         public GamepadStateSnapshot GetMappedStateSnapshot()
         {
             KeyboardStateSnapshot rawState = GetKeyboardStateSnapshot();
-            GamepadStateSnapshot result = default;
+            GamepadStateSnapshot  result   = default;
 
             lock (_userMappingLock)
             {
-                if (!HasConfiguration)
+                if (_configuration == null)
                 {
                     return result;
                 }
@@ -62,17 +68,17 @@ namespace Ryujinx.Ava.Input
                         continue;
                     }
 
-                    // Do not touch state of the button already pressed
+                    // NOTE: Do not touch state of the button already pressed.
                     if (!result.IsPressed(entry.To))
                     {
                         result.SetPressed(entry.To, rawState.IsPressed(entry.From));
                     }
                 }
 
-                (short leftStickX, short leftStickY) = GetStickValues(ref rawState, _configuration.LeftJoyconStick);
+                (short leftStickX,  short leftStickY)  = GetStickValues(ref rawState, _configuration.LeftJoyconStick);
                 (short rightStickX, short rightStickY) = GetStickValues(ref rawState, _configuration.RightJoyconStick);
 
-                result.SetStick(StickInputId.Left, ConvertRawStickValue(leftStickX), ConvertRawStickValue(leftStickY));
+                result.SetStick(StickInputId.Left,  ConvertRawStickValue(leftStickX),  ConvertRawStickValue(leftStickY));
                 result.SetStick(StickInputId.Right, ConvertRawStickValue(rightStickX), ConvertRawStickValue(rightStickY));
             }
 
@@ -114,29 +120,29 @@ namespace Ryujinx.Ava.Input
 
                 _buttonsUserMapping.Clear();
 
-                // Left joycon
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick, (Key)_configuration.LeftJoyconStick.StickButton));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp, (Key)_configuration.LeftJoycon.DpadUp));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown, (Key)_configuration.LeftJoycon.DpadDown));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadLeft, (Key)_configuration.LeftJoycon.DpadLeft));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadRight, (Key)_configuration.LeftJoycon.DpadRight));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Minus, (Key)_configuration.LeftJoycon.ButtonMinus));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftShoulder, (Key)_configuration.LeftJoycon.ButtonL));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftTrigger, (Key)_configuration.LeftJoycon.ButtonZl));
+                // Left JoyCon
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick,           (Key)_configuration.LeftJoyconStick.StickButton));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp,              (Key)_configuration.LeftJoycon.DpadUp));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown,            (Key)_configuration.LeftJoycon.DpadDown));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadLeft,            (Key)_configuration.LeftJoycon.DpadLeft));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadRight,           (Key)_configuration.LeftJoycon.DpadRight));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Minus,               (Key)_configuration.LeftJoycon.ButtonMinus));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftShoulder,        (Key)_configuration.LeftJoycon.ButtonL));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftTrigger,         (Key)_configuration.LeftJoycon.ButtonZl));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, (Key)_configuration.LeftJoycon.ButtonSr));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, (Key)_configuration.LeftJoycon.ButtonSl));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0,  (Key)_configuration.LeftJoycon.ButtonSl));
 
-                // Finally right joycon
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick, (Key)_configuration.RightJoyconStick.StickButton));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A, (Key)_configuration.RightJoycon.ButtonA));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B, (Key)_configuration.RightJoycon.ButtonB));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.X, (Key)_configuration.RightJoycon.ButtonX));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Y, (Key)_configuration.RightJoycon.ButtonY));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Plus, (Key)_configuration.RightJoycon.ButtonPlus));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightShoulder, (Key)_configuration.RightJoycon.ButtonR));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightTrigger, (Key)_configuration.RightJoycon.ButtonZr));
+                // Right JoyCon
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick,          (Key)_configuration.RightJoyconStick.StickButton));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A,                   (Key)_configuration.RightJoycon.ButtonA));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B,                   (Key)_configuration.RightJoycon.ButtonB));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.X,                   (Key)_configuration.RightJoycon.ButtonX));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Y,                   (Key)_configuration.RightJoycon.ButtonY));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Plus,                (Key)_configuration.RightJoycon.ButtonPlus));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightShoulder,       (Key)_configuration.RightJoycon.ButtonR));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightTrigger,        (Key)_configuration.RightJoycon.ButtonZr));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, (Key)_configuration.RightJoycon.ButtonSr));
-                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, (Key)_configuration.RightJoycon.ButtonSl));
+                _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1,  (Key)_configuration.RightJoycon.ButtonSl));
             }
         }
 
@@ -190,16 +196,6 @@ namespace Ryujinx.Ava.Input
             _driver?.ResetKeys();
         }
 
-        private class ButtonMappingEntry
-        {
-            public readonly Key From;
-            public readonly GamepadButtonInputId To;
-
-            public ButtonMappingEntry(GamepadButtonInputId to, Key from)
-            {
-                To = to;
-                From = from;
-            }
-        }
+        public void Dispose() { }
     }
 }

Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs

@@ -4,7 +4,6 @@ using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Input;
 using System;
 using System.Collections.Generic;
-
 using AvaKey = Avalonia.Input.Key;
 using Key = Ryujinx.Input.Key;
 
@@ -13,24 +12,23 @@ namespace Ryujinx.Ava.Input
     internal class AvaloniaKeyboardDriver : IGamepadDriver
     {
         private static readonly string[] _keyboardIdentifers = new string[1] { "0" };
-        private readonly Control _control;
+        private readonly Control         _control;
         private readonly HashSet<AvaKey> _pressedKeys;
 
         public event EventHandler<KeyEventArgs> KeyPressed;
         public event EventHandler<KeyEventArgs> KeyRelease;
-        public event EventHandler<string> TextInput;
-
-        public string DriverName => "Avalonia";
+        public event EventHandler<string>       TextInput;
 
+        public string               DriverName  => "AvaloniaKeyboardDriver";
         public ReadOnlySpan<string> GamepadsIds => _keyboardIdentifers;
 
         public AvaloniaKeyboardDriver(Control control)
         {
-            _control = control;
+            _control     = control;
             _pressedKeys = new HashSet<AvaKey>();
 
-            _control.KeyDown += OnKeyPress;
-            _control.KeyUp += OnKeyRelease;
+            _control.KeyDown   += OnKeyPress;
+            _control.KeyUp     += OnKeyRelease;
             _control.TextInput += Control_TextInput;
         }
 
@@ -41,21 +39,16 @@ namespace Ryujinx.Ava.Input
 
         public event Action<string> OnGamepadConnected
         {
-            add { }
+            add    { }
             remove { }
         }
 
         public event Action<string> OnGamepadDisconnected
         {
-            add { }
+            add    { }
             remove { }
         }
 
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
         public IGamepad GetGamepad(string id)
         {
             if (!_keyboardIdentifers[0].Equals(id))
@@ -70,15 +63,13 @@ namespace Ryujinx.Ava.Input
         {
             if (disposing)
             {
-                _control.KeyUp -= OnKeyPress;
+                _control.KeyUp   -= OnKeyPress;
                 _control.KeyDown -= OnKeyRelease;
             }
         }
 
         protected void OnKeyPress(object sender, KeyEventArgs args)
         {
-            AvaKey key = args.Key;
-
             _pressedKeys.Add(args.Key);
 
             KeyPressed?.Invoke(this, args);
@@ -98,7 +89,7 @@ namespace Ryujinx.Ava.Input
                 return false;
             }
 
-            AvaloniaMappingHelper.TryGetAvaKey(key, out var nativeKey);
+            AvaloniaKeyboardMappingHelper.TryGetAvaKey(key, out var nativeKey);
 
             return _pressedKeys.Contains(nativeKey);
         }
@@ -107,5 +98,10 @@ namespace Ryujinx.Ava.Input
         {
             _pressedKeys.Clear();
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
     }
 }

Ryujinx.Ava/Input/AvaloniaKeyboardMappingHelper.cs

@@ -5,7 +5,7 @@ using AvaKey = Avalonia.Input.Key;
 
 namespace Ryujinx.Ava.Input
 {
-    internal static class AvaloniaMappingHelper
+    internal static class AvaloniaKeyboardMappingHelper
     {
         private static readonly AvaKey[] _keyMapping = new AvaKey[(int)Key.Count]
         {
@@ -149,11 +149,11 @@ namespace Ryujinx.Ava.Input
 
         private static readonly Dictionary<AvaKey, Key> _avaKeyMapping;
 
-        static AvaloniaMappingHelper()
+        static AvaloniaKeyboardMappingHelper()
         {
             var inputKeys = Enum.GetValues(typeof(Key));
 
-            // Avalonia.Input.Key is not contiguous and quite large, so use a dictionary instead of an array.
+            // NOTE: Avalonia.Input.Key is not contiguous and quite large, so use a dictionary instead of an array.
             _avaKeyMapping = new Dictionary<AvaKey, Key>();
 
             foreach (var key in inputKeys)
@@ -167,15 +167,13 @@ namespace Ryujinx.Ava.Input
 
         public static bool TryGetAvaKey(Key key, out AvaKey avaKey)
         {
-            var keyExist = (int)key < _keyMapping.Length;
+            avaKey = AvaKey.None;
+
+            bool keyExist = (int)key < _keyMapping.Length;
             if (keyExist)
             {
                 avaKey = _keyMapping[(int)key];
             }
-            else
-            {
-                avaKey = AvaKey.None;
-            }
 
             return keyExist;
         }

Ryujinx.Ava/Input/AvaloniaMouse.cs

@@ -10,15 +10,12 @@ namespace Ryujinx.Ava.Input
     {
         private AvaloniaMouseDriver _driver;
 
-        public GamepadFeaturesFlag Features => throw new NotImplementedException();
-
-        public string Id => "0";
-
+        public string Id   => "0";
         public string Name => "AvaloniaMouse";
 
-        public bool IsConnected => true;
-
-        public bool[] Buttons => _driver.PressedButtons;
+        public bool                IsConnected => true;
+        public GamepadFeaturesFlag Features    => throw new NotImplementedException();
+        public bool[]              Buttons     => _driver.PressedButtons;
 
         public AvaloniaMouse(AvaloniaMouseDriver driver)
         {

Ryujinx.Ava/Input/AvaloniaMouseDriver.cs

@@ -11,35 +11,50 @@ namespace Ryujinx.Ava.Input
 {
     internal class AvaloniaMouseDriver : IGamepadDriver
     {
-        private Control _widget;
-        private bool _isDisposed;
-        private Size _size;
+        private Control         _widget;
+        private bool            _isDisposed;
+        private Size            _size;
         private readonly Window _window;
 
-        public bool[] PressedButtons { get; }
-
+        public bool[]  PressedButtons  { get; }
         public Vector2 CurrentPosition { get; private set; }
-        public Vector2 Scroll { get; private set; }
+        public Vector2 Scroll          { get; private set; }
+
+        public string               DriverName  => "AvaloniaMouseDriver";
+        public ReadOnlySpan<string> GamepadsIds => new[] { "0" };
 
         public AvaloniaMouseDriver(Window window, Control parent)
         {
             _widget = parent;
             _window = window;
 
-            _widget.PointerMoved += Parent_PointerMovedEvent;
-            _widget.PointerPressed += Parent_PointerPressEvent;
-            _widget.PointerReleased += Parent_PointerReleaseEvent;
+            _widget.PointerMoved        += Parent_PointerMovedEvent;
+            _widget.PointerPressed      += Parent_PointerPressEvent;
+            _widget.PointerReleased     += Parent_PointerReleaseEvent;
             _widget.PointerWheelChanged += Parent_ScrollEvent;
             
-            _window.PointerMoved += Parent_PointerMovedEvent;
-            _window.PointerPressed += Parent_PointerPressEvent;
-            _window.PointerReleased += Parent_PointerReleaseEvent;
+            _window.PointerMoved        += Parent_PointerMovedEvent;
+            _window.PointerPressed      += Parent_PointerPressEvent;
+            _window.PointerReleased     += Parent_PointerReleaseEvent;
             _window.PointerWheelChanged += Parent_ScrollEvent;
 
             PressedButtons = new bool[(int)MouseButton.Count];
 
             _size = new Size((int)parent.Bounds.Width, (int)parent.Bounds.Height);
-            parent.GetObservable(Control.BoundsProperty).Subscribe(Resized);
+
+            parent.GetObservable(Visual.BoundsProperty).Subscribe(Resized);
+        }
+
+        public event Action<string> OnGamepadConnected
+        {
+            add    { }
+            remove { }
+        }
+
+        public event Action<string> OnGamepadDisconnected
+        {
+            add    { }
+            remove { }
         }
 
         private void Resized(Rect rect)
@@ -59,14 +74,12 @@ namespace Ryujinx.Ava.Input
 
         private void Parent_PointerPressEvent(object o, PointerPressedEventArgs args)
         {
-            var pointerProperties = args.GetCurrentPoint(_widget).Properties;
-
-            PressedButtons[(int)pointerProperties.PointerUpdateKind] = true;
+            PressedButtons[(int)args.GetCurrentPoint(_widget).Properties.PointerUpdateKind] = true;
         }
 
         private void Parent_PointerMovedEvent(object o, PointerEventArgs args)
         {
-            var position = args.GetPosition(_widget);
+            Point position = args.GetPosition(_widget);
 
             CurrentPosition = new Vector2((float)position.X, (float)position.Y);
         }
@@ -96,22 +109,6 @@ namespace Ryujinx.Ava.Input
             return _size;
         }
 
-        public string DriverName => "Avalonia";
-
-        public event Action<string> OnGamepadConnected
-        {
-            add { }
-            remove { }
-        }
-
-        public event Action<string> OnGamepadDisconnected
-        {
-            add { }
-            remove { }
-        }
-
-        public ReadOnlySpan<string> GamepadsIds => new[] { "0" };
-
         public IGamepad GetGamepad(string id)
         {
             return new AvaloniaMouse(this);
@@ -126,14 +123,14 @@ namespace Ryujinx.Ava.Input
 
             _isDisposed = true;
 
-            _widget.PointerMoved -= Parent_PointerMovedEvent;
-            _widget.PointerPressed -= Parent_PointerPressEvent;
-            _widget.PointerReleased -= Parent_PointerReleaseEvent;
+            _widget.PointerMoved        -= Parent_PointerMovedEvent;
+            _widget.PointerPressed      -= Parent_PointerPressEvent;
+            _widget.PointerReleased     -= Parent_PointerReleaseEvent;
             _widget.PointerWheelChanged -= Parent_ScrollEvent;
 
-            _window.PointerMoved -= Parent_PointerMovedEvent;
-            _window.PointerPressed -= Parent_PointerPressEvent;
-            _window.PointerReleased -= Parent_PointerReleaseEvent;
+            _window.PointerMoved        -= Parent_PointerMovedEvent;
+            _window.PointerPressed      -= Parent_PointerPressEvent;
+            _window.PointerReleased     -= Parent_PointerReleaseEvent;
             _window.PointerWheelChanged -= Parent_ScrollEvent;
 
             _widget = null;

Ryujinx.Ava/Modules/Updater/Updater.cs

@@ -355,7 +355,7 @@ namespace Ryujinx.Modules
                         list[index] = args.Result;
                         Interlocked.Increment(ref completedRequests);
 
-                        if (Interlocked.Equals(completedRequests, ConnectionCount))
+                        if (Equals(completedRequests, ConnectionCount))
                         {
                             byte[] mergedFileBytes = new byte[_buildSize];
                             for (int connectionIndex = 0, destinationOffset = 0; connectionIndex < ConnectionCount; connectionIndex++)

Ryujinx.Ava/Program.cs

@@ -1,5 +1,6 @@
 using ARMeilleure.Translation.PTC;
 using Avalonia;
+using Avalonia.Threading;
 using Ryujinx.Ava.Ui.Windows;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
@@ -8,6 +9,7 @@ using Ryujinx.Common.Logging;
 using Ryujinx.Common.System;
 using Ryujinx.Common.SystemInfo;
 using Ryujinx.Modules;
+using Ryujinx.SDL2.Common;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Helper;
@@ -20,10 +22,11 @@ namespace Ryujinx.Ava
 {
     internal class Program
     {
-        public static double WindowScaleFactor { get; set; }
-        public static string Version           { get; private set; }
-        public static string ConfigurationPath { get; private set; }
-        public static bool   PreviewerDetached { get; private set; }
+        public static double WindowScaleFactor  { get; set; }
+        public static double DesktopScaleFactor { get; set; } = 1.0;
+        public static string Version            { get; private set; }
+        public static string ConfigurationPath  { get; private set; }
+        public static bool   PreviewerDetached {  get; private set; }
 
         [DllImport("user32.dll", SetLastError = true)]
         public static extern int MessageBoxA(IntPtr hWnd, string text, string caption, uint type);
@@ -79,8 +82,8 @@ namespace Ryujinx.Ava
             Console.Title = $"Ryujinx Console {Version}";
 
             // Hook unhandled exception and process exit events.
-            AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) => ProcessUnhandledException(e.ExceptionObject as Exception, e.IsTerminating);
-            AppDomain.CurrentDomain.ProcessExit        += (object sender, EventArgs e)                   => Exit();
+            AppDomain.CurrentDomain.UnhandledException += (sender, e) => ProcessUnhandledException(e.ExceptionObject as Exception, e.IsTerminating);
+            AppDomain.CurrentDomain.ProcessExit        += (sender, e) => Exit();
 
             // Setup base data directory.
             AppDataManager.Initialize(CommandLineState.BaseDirPathArg);
@@ -94,6 +97,9 @@ namespace Ryujinx.Ava
             // Initialize Discord integration.
             DiscordIntegrationModule.Initialize();
 
+            // Initialize SDL2 driver
+            SDL2Driver.MainThreadDispatcher = action => Dispatcher.UIThread.InvokeAsync(action, DispatcherPriority.Input);
+
             ReloadConfig();
 
             ForceDpiAware.Windows();
@@ -219,4 +225,4 @@ namespace Ryujinx.Ava
             Logger.Shutdown();
         }
     }
-}
+}

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -26,19 +26,23 @@
     <PackageReference Include="Avalonia.Svg" Version="0.10.18" />
     <PackageReference Include="Avalonia.Svg.Skia" Version="0.10.18" />
     <PackageReference Include="jp2masa.Avalonia.Flexbox" Version="0.2.0" />
-    <PackageReference Include="DynamicData" Version="7.12.8" />
+    <PackageReference Include="DynamicData" Version="7.12.11" />
     <PackageReference Include="FluentAvaloniaUI" Version="1.4.5" />
-    <PackageReference Include="XamlNameReferenceGenerator" Version="1.4.2" />
+    <PackageReference Include="XamlNameReferenceGenerator" Version="1.5.1" />
 
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
-    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
+    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build12" />
+    <PackageReference Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="Silk.NET.Vulkan" Version="2.16.0" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.16.0" />
     <PackageReference Include="SPB" Version="0.0.4-build28" />
     <PackageReference Include="SharpZipLib" Version="1.4.1" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
+
+    <!--NOTE: DO NOT REMOVE, THIS IS REQUIRED AS A RESULT OF A TRIMMING ISSUE IN AVALONIA -->
+    <PackageReference Include="System.Drawing.Common" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -57,14 +61,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ContentWithTargetPath Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
+    <Content Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>alsoft.ini</TargetPath>
-    </ContentWithTargetPath>
-    <ContentWithTargetPath Include="..\distribution\legal\THIRDPARTY.md">
+    </Content>
+    <Content Include="..\distribution\legal\THIRDPARTY.md">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>THIRDPARTY.md</TargetPath>
-    </ContentWithTargetPath>
+    </Content>
+    <Content Include="..\LICENSE.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <TargetPath>LICENSE.txt</TargetPath>
+    </Content>
   </ItemGroup>
 
   <ItemGroup>

Ryujinx.Ava/Ui/Applet/AvaloniaDynamicTextInputHandler.cs

@@ -66,9 +66,9 @@ namespace Ryujinx.Ava.Ui.Applet
             });
         }
 
-        private void AvaloniaDynamicTextInputHandler_KeyRelease(object sender, Avalonia.Input.KeyEventArgs e)
+        private void AvaloniaDynamicTextInputHandler_KeyRelease(object sender, KeyEventArgs e)
         {
-            var key = (HidKey)AvaloniaMappingHelper.ToInputKey(e.Key);
+            var key = (HidKey)AvaloniaKeyboardMappingHelper.ToInputKey(e.Key);
 
             if (!(KeyReleasedEvent?.Invoke(key)).GetValueOrDefault(true))
             {
@@ -88,7 +88,7 @@ namespace Ryujinx.Ava.Ui.Applet
 
         private void AvaloniaDynamicTextInputHandler_KeyPressed(object sender, KeyEventArgs e)
         {
-            var key = (HidKey)AvaloniaMappingHelper.ToInputKey(e.Key);
+            var key = (HidKey)AvaloniaKeyboardMappingHelper.ToInputKey(e.Key);
 
             if (!(KeyPressedEvent?.Invoke(key)).GetValueOrDefault(true))
             {

Ryujinx.Ava/Ui/Applet/ErrorAppletWindow.axaml

@@ -11,7 +11,8 @@
     Height="340"
     CanResize="False"
     SizeToContent="Height"
-    mc:Ignorable="d">
+    mc:Ignorable="d"
+    Focusable="True">
     <Grid
         Margin="20"
         HorizontalAlignment="Stretch"

Ryujinx.Ava/Ui/Applet/SwkbdAppletDialog.axaml

@@ -6,7 +6,8 @@
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:window="clr-namespace:Ryujinx.Ava.Ui.Windows"
     Width="400"
-    mc:Ignorable="d">
+    mc:Ignorable="d"
+    Focusable="True">
     <Grid
         Margin="20"
         HorizontalAlignment="Stretch"