Fix resolution scale values not being updated (#3514)

* Fix geometry shader passthrough fallback being used when feature is supported

* Shader cache version bump

ARMeilleure/Signal/NativeSignalHandler.cs

@@ -197,12 +197,29 @@ namespace ARMeilleure.Signal
                 // Only call tracking if in range.
                 context.BranchIfFalse(nextLabel, inRange, BasicBlockFrequency.Cold);
 
-                context.Copy(inRegionLocal, Const(1));
                 Operand offset = context.BitwiseAnd(context.Subtract(faultAddress, rangeAddress), Const(~PageMask));
 
                 // Call the tracking action, with the pointer's relative offset to the base address.
                 Operand trackingActionPtr = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 20));
-                context.Call(trackingActionPtr, OperandType.I32, offset, Const(PageSize), isWrite, Const(0));
+
+                context.Copy(inRegionLocal, Const(0));
+
+                Operand skipActionLabel = Label();
+
+                // Tracking action should be non-null to call it, otherwise assume false return.
+                context.BranchIfFalse(skipActionLabel, trackingActionPtr);
+                Operand result = context.Call(trackingActionPtr, OperandType.I32, offset, Const(PageSize), isWrite, Const(0));
+                context.Copy(inRegionLocal, result);
+
+                context.MarkLabel(skipActionLabel);
+
+                // If the tracking action returns false or does not exist, it might be an invalid access due to a partial overlap on Windows.
+                if (OperatingSystem.IsWindows())
+                {
+                    context.BranchIfTrue(endLabel, inRegionLocal);
+
+                    context.Copy(inRegionLocal, WindowsPartialUnmapHandler.EmitRetryFromAccessViolation(context));
+                }
 
                 context.Branch(endLabel);
 

ARMeilleure/Signal/TestMethods.cs

@@ -0,0 +1,84 @@
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using System;
+
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+
+namespace ARMeilleure.Signal
+{
+    public struct NativeWriteLoopState
+    {
+        public int Running;
+        public int Error;
+    }
+
+    public static class TestMethods
+    {
+        public delegate bool DebugPartialUnmap();
+        public delegate int DebugThreadLocalMapGetOrReserve(int threadId, int initialState);
+        public delegate void DebugNativeWriteLoop(IntPtr nativeWriteLoopPtr, IntPtr writePtr);
+
+        public static DebugPartialUnmap GenerateDebugPartialUnmap()
+        {
+            EmitterContext context = new EmitterContext();
+
+            var result = WindowsPartialUnmapHandler.EmitRetryFromAccessViolation(context);
+
+            context.Return(result);
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq).Map<DebugPartialUnmap>();
+        }
+
+        public static DebugThreadLocalMapGetOrReserve GenerateDebugThreadLocalMapGetOrReserve(IntPtr structPtr)
+        {
+            EmitterContext context = new EmitterContext();
+
+            var result = WindowsPartialUnmapHandler.EmitThreadLocalMapIntGetOrReserve(context, structPtr, context.LoadArgument(OperandType.I32, 0), context.LoadArgument(OperandType.I32, 1));
+
+            context.Return(result);
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq).Map<DebugThreadLocalMapGetOrReserve>();
+        }
+
+        public static DebugNativeWriteLoop GenerateDebugNativeWriteLoop()
+        {
+            EmitterContext context = new EmitterContext();
+
+            // Loop a write to the target address until "running" is false.
+
+            Operand structPtr = context.Copy(context.LoadArgument(OperandType.I64, 0));
+            Operand writePtr = context.Copy(context.LoadArgument(OperandType.I64, 1));
+
+            Operand loopLabel = Label();
+            context.MarkLabel(loopLabel);
+
+            context.Store(writePtr, Const(12345));
+
+            Operand running = context.Load(OperandType.I32, structPtr);
+
+            context.BranchIfTrue(loopLabel, running);
+
+            context.Return();
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.None, CompilerOptions.HighCq).Map<DebugNativeWriteLoop>();
+        }
+    }
+}

ARMeilleure/Signal/WindowsPartialUnmapHandler.cs

@@ -0,0 +1,186 @@
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using Ryujinx.Common.Memory.PartialUnmaps;
+using System;
+
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+
+namespace ARMeilleure.Signal
+{
+    /// <summary>
+    /// Methods to handle signals caused by partial unmaps. See the structs for C# implementations of the methods.
+    /// </summary>
+    internal static class WindowsPartialUnmapHandler
+    {
+        public static Operand EmitRetryFromAccessViolation(EmitterContext context)
+        {
+            IntPtr partialRemapStatePtr = PartialUnmapState.GlobalState;
+            IntPtr localCountsPtr = IntPtr.Add(partialRemapStatePtr, PartialUnmapState.LocalCountsOffset);
+
+            // Get the lock first.
+            EmitNativeReaderLockAcquire(context, IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapLockOffset));
+
+            IntPtr getCurrentThreadId = WindowsSignalHandlerRegistration.GetCurrentThreadIdFunc();
+            Operand threadId = context.Call(Const((ulong)getCurrentThreadId), OperandType.I32);
+            Operand threadIndex = EmitThreadLocalMapIntGetOrReserve(context, localCountsPtr, threadId, Const(0));
+
+            Operand endLabel = Label();
+            Operand retry = context.AllocateLocal(OperandType.I32);
+            Operand threadIndexValidLabel = Label();
+
+            context.BranchIfFalse(threadIndexValidLabel, context.ICompareEqual(threadIndex, Const(-1)));
+
+            context.Copy(retry, Const(1)); // Always retry when thread local cannot be allocated.
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(threadIndexValidLabel);
+
+            Operand threadLocalPartialUnmapsPtr = EmitThreadLocalMapIntGetValuePtr(context, localCountsPtr, threadIndex);
+            Operand threadLocalPartialUnmaps = context.Load(OperandType.I32, threadLocalPartialUnmapsPtr);
+            Operand partialUnmapsCount = context.Load(OperandType.I32, Const((ulong)IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapsCountOffset)));
+
+            context.Copy(retry, context.ICompareNotEqual(threadLocalPartialUnmaps, partialUnmapsCount));
+
+            Operand noRetryLabel = Label();
+
+            context.BranchIfFalse(noRetryLabel, retry);
+
+            // if (retry) {
+
+            context.Store(threadLocalPartialUnmapsPtr, partialUnmapsCount);
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(noRetryLabel);
+
+            // }
+
+            context.MarkLabel(endLabel);
+
+            // Finally, release the lock and return the retry value.
+            EmitNativeReaderLockRelease(context, IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapLockOffset));
+
+            return retry;
+        }
+
+        public static Operand EmitThreadLocalMapIntGetOrReserve(EmitterContext context, IntPtr threadLocalMapPtr, Operand threadId, Operand initialState)
+        {
+            Operand idsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.ThreadIdsOffset));
+
+            Operand i = context.AllocateLocal(OperandType.I32);
+
+            context.Copy(i, Const(0));
+
+            // (Loop 1) Check all slots for a matching Thread ID (while also trying to allocate)
+
+            Operand endLabel = Label();
+
+            Operand loopLabel = Label();
+            context.MarkLabel(loopLabel);
+
+            Operand offset = context.Multiply(i, Const(sizeof(int)));
+            Operand idPtr = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset));
+
+            // Check that this slot has the thread ID.
+            Operand existingId = context.CompareAndSwap(idPtr, threadId, threadId);
+
+            // If it was already the thread ID, then we just need to return i.
+            context.BranchIfTrue(endLabel, context.ICompareEqual(existingId, threadId));
+
+            context.Copy(i, context.Add(i, Const(1)));
+
+            context.BranchIfTrue(loopLabel, context.ICompareLess(i, Const(ThreadLocalMap<int>.MapSize)));
+
+            // (Loop 2) Try take a slot that is 0 with our Thread ID.
+
+            context.Copy(i, Const(0)); // Reset i.
+
+            Operand loop2Label = Label();
+            context.MarkLabel(loop2Label);
+
+            Operand offset2 = context.Multiply(i, Const(sizeof(int)));
+            Operand idPtr2 = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset2));
+
+            // Try and swap in the thread id on top of 0.
+            Operand existingId2 = context.CompareAndSwap(idPtr2, Const(0), threadId);
+
+            Operand idNot0Label = Label();
+
+            // If it was 0, then we need to initialize the struct entry and return i.
+            context.BranchIfFalse(idNot0Label, context.ICompareEqual(existingId2, Const(0)));
+
+            Operand structsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.StructsOffset));
+            Operand structPtr = context.Add(structsPtr, context.SignExtend32(OperandType.I64, offset2));
+            context.Store(structPtr, initialState);
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(idNot0Label);
+
+            context.Copy(i, context.Add(i, Const(1)));
+
+            context.BranchIfTrue(loop2Label, context.ICompareLess(i, Const(ThreadLocalMap<int>.MapSize)));
+
+            context.Copy(i, Const(-1)); // Could not place the thread in the list.
+
+            context.MarkLabel(endLabel);
+
+            return context.Copy(i);
+        }
+
+        private static Operand EmitThreadLocalMapIntGetValuePtr(EmitterContext context, IntPtr threadLocalMapPtr, Operand index)
+        {
+            Operand offset = context.Multiply(index, Const(sizeof(int)));
+            Operand structsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.StructsOffset));
+
+            return context.Add(structsPtr, context.SignExtend32(OperandType.I64, offset));
+        }
+
+        private static void EmitThreadLocalMapIntRelease(EmitterContext context, IntPtr threadLocalMapPtr, Operand threadId, Operand index)
+        {
+            Operand offset = context.Multiply(index, Const(sizeof(int)));
+            Operand idsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.ThreadIdsOffset));
+            Operand idPtr = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset));
+
+            context.CompareAndSwap(idPtr, threadId, Const(0));
+        }
+
+        private static void EmitAtomicAddI32(EmitterContext context, Operand ptr, Operand additive)
+        {
+            Operand loop = Label();
+            context.MarkLabel(loop);
+
+            Operand initial = context.Load(OperandType.I32, ptr);
+            Operand newValue = context.Add(initial, additive);
+
+            Operand replaced = context.CompareAndSwap(ptr, initial, newValue);
+
+            context.BranchIfFalse(loop, context.ICompareEqual(initial, replaced));
+        }
+
+        private static void EmitNativeReaderLockAcquire(EmitterContext context, IntPtr nativeReaderLockPtr)
+        {
+            Operand writeLockPtr = Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.WriteLockOffset));
+
+            // Spin until we can acquire the write lock.
+            Operand spinLabel = Label();
+            context.MarkLabel(spinLabel);
+
+            // Old value must be 0 to continue (we gained the write lock)
+            context.BranchIfTrue(spinLabel, context.CompareAndSwap(writeLockPtr, Const(0), Const(1)));
+
+            // Increment reader count.
+            EmitAtomicAddI32(context, Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.ReaderCountOffset)), Const(1));
+
+            // Release write lock.
+            context.CompareAndSwap(writeLockPtr, Const(1), Const(0));
+        }
+
+        private static void EmitNativeReaderLockRelease(EmitterContext context, IntPtr nativeReaderLockPtr)
+        {
+            // Decrement reader count.
+            EmitAtomicAddI32(context, Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.ReaderCountOffset)), Const(-1));
+        }
+    }
+}

ARMeilleure/Signal/WindowsSignalHandlerRegistration.cs

@@ -1,9 +1,10 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Signal
 {
-    class WindowsSignalHandlerRegistration
+    unsafe class WindowsSignalHandlerRegistration
     {
         [DllImport("kernel32.dll")]
         private static extern IntPtr AddVectoredExceptionHandler(uint first, IntPtr handler);
@@ -11,6 +12,14 @@ namespace ARMeilleure.Signal
         [DllImport("kernel32.dll")]
         private static extern ulong RemoveVectoredExceptionHandler(IntPtr handle);
 
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Ansi)]
+        static extern IntPtr LoadLibrary([MarshalAs(UnmanagedType.LPStr)] string lpFileName);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
+        private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
+
+        private static IntPtr _getCurrentThreadIdPtr;
+
         public static IntPtr RegisterExceptionHandler(IntPtr action)
         {
             return AddVectoredExceptionHandler(1, action);
@@ -20,5 +29,17 @@ namespace ARMeilleure.Signal
         {
             return RemoveVectoredExceptionHandler(handle) != 0;
         }
+
+        public static IntPtr GetCurrentThreadIdFunc()
+        {
+            if (_getCurrentThreadIdPtr == IntPtr.Zero)
+            {
+                IntPtr handle = LoadLibrary("kernel32.dll");
+
+                _getCurrentThreadIdPtr = GetProcAddress(handle, "GetCurrentThreadId");
+            }
+
+            return _getCurrentThreadIdPtr;
+        }
     }
 }

Ryujinx.Audio/AudioManager.cs

@@ -129,4 +129,4 @@ namespace Ryujinx.Audio
             }
         }
     }
-}
+}

Ryujinx.Audio/Backends/Common/BackendHelper.cs

@@ -23,4 +23,4 @@ namespace Ryujinx.Audio.Backends.Common
             return bufferSize / GetSampleSize(format) / channelCount;
         }
     }
-}
+}

Ryujinx.Audio/Backends/Common/DynamicRingBuffer.cs

@@ -163,4 +163,4 @@ namespace Ryujinx.Audio.Backends.Common
             }
         }
     }
-}
+}

Ryujinx.Audio/Backends/Common/HardwareDeviceSessionOutputBase.cs

@@ -76,4 +76,4 @@ namespace Ryujinx.Audio.Backends.Common
 
         public virtual void UnregisterBuffer(AudioBuffer buffer) { }
     }
-}
+}

Ryujinx.Audio/Backends/CompatLayer/CompatLayerHardwareDeviceDriver.cs

@@ -133,4 +133,4 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             return direction == Direction.Input || direction == Direction.Output;
         }
     }
-}
+}

Ryujinx.Audio/Backends/CompatLayer/CompatLayerHardwareDeviceSession.cs

@@ -81,7 +81,7 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             {
                 BufferTag = buffer.BufferTag,
                 DataPointer = buffer.DataPointer,
-                DataSize  = (ulong)downmixedBuffer.Length
+                DataSize = (ulong)downmixedBuffer.Length
             };
 
             bool result = _realSession.RegisterBuffer(fakeBuffer, downmixedBuffer);
@@ -120,4 +120,4 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             return _realSession.WasBufferFullyConsumed(buffer);
         }
     }
-}
+}

Ryujinx.Audio/Backends/CompatLayer/Downmixing.cs

@@ -24,11 +24,11 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             public short Right;
         }
 
-        private const int Q15Bits        = 16;
-        private const int RawQ15One      = 1 << Q15Bits;
-        private const int RawQ15HalfOne  = (int)(0.5f * RawQ15One);
-        private const int Minus3dBInQ15  = (int)(0.707f * RawQ15One);
-        private const int Minus6dBInQ15  = (int)(0.501f * RawQ15One);
+        private const int Q15Bits = 16;
+        private const int RawQ15One = 1 << Q15Bits;
+        private const int RawQ15HalfOne = (int)(0.5f * RawQ15One);
+        private const int Minus3dBInQ15 = (int)(0.707f * RawQ15One);
+        private const int Minus6dBInQ15 = (int)(0.501f * RawQ15One);
         private const int Minus12dBInQ15 = (int)(0.251f * RawQ15One);
 
         private static readonly int[] DefaultSurroundToStereoCoefficients = new int[4]
@@ -46,8 +46,8 @@ namespace Ryujinx.Audio.Backends.CompatLayer
         };
 
         private const int SurroundChannelCount = 6;
-        private const int StereoChannelCount   = 2;
-        private const int MonoChannelCount     = 1;
+        private const int StereoChannelCount = 2;
+        private const int MonoChannelCount = 1;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static ReadOnlySpan<Channel51FormatPCM16> GetSurroundBuffer(ReadOnlySpan<short> data)
@@ -86,7 +86,7 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             {
                 Channel51FormatPCM16 channel = channels[i];
 
-                downmixedBuffer[i * 2]     = DownMixSurroundToStereo(coefficients, channel.BackLeft, channel.LowFrequency, channel.FrontCenter, channel.FrontLeft);
+                downmixedBuffer[i * 2] = DownMixSurroundToStereo(coefficients, channel.BackLeft, channel.LowFrequency, channel.FrontCenter, channel.FrontLeft);
                 downmixedBuffer[i * 2 + 1] = DownMixSurroundToStereo(coefficients, channel.BackRight, channel.LowFrequency, channel.FrontCenter, channel.FrontRight);
             }
 
@@ -122,4 +122,4 @@ namespace Ryujinx.Audio.Backends.CompatLayer
             return DownMixSurroundToStereo(DefaultSurroundToStereoCoefficients, data);
         }
     }
-}
+}

Ryujinx.Audio/Backends/Dummy/DummyHardwareDeviceDriver.cs

@@ -84,4 +84,4 @@ namespace Ryujinx.Audio.Backends.Dummy
             return channelCount == 1 || channelCount == 2 || channelCount == 6;
         }
     }
-}
+}

Ryujinx.Audio/Backends/Dummy/DummyHardwareDeviceSessionInput.cs

@@ -64,4 +64,4 @@ namespace Ryujinx.Audio.Backends.Dummy
             return true;
         }
     }
-}
+}

Ryujinx.Audio/Common/AudioBuffer.cs

@@ -34,4 +34,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         public byte[] Data;
     }
-}
+}

Ryujinx.Audio/Common/AudioDeviceSession.cs

@@ -513,4 +513,4 @@ namespace Ryujinx.Audio.Common
             }
         }
     }
-}
+}

Ryujinx.Audio/Common/AudioDeviceState.cs

@@ -15,4 +15,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         Stopped
     }
-}
+}

Ryujinx.Audio/Common/AudioInputConfiguration.cs

@@ -26,4 +26,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         private ushort _reserved;
     }
-}
+}

Ryujinx.Audio/Common/AudioOutputConfiguration.cs

@@ -34,4 +34,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         public AudioDeviceState AudioOutState;
     }
-}
+}

Ryujinx.Audio/Common/AudioUserBuffer.cs

@@ -33,4 +33,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         public ulong DataOffset;
     }
-}
+}

Ryujinx.Audio/Common/SampleFormat.cs

@@ -40,4 +40,4 @@ namespace Ryujinx.Audio.Common
         /// </summary>
         Adpcm = 6
     }
-}
+}

Ryujinx.Audio/Constants.cs

@@ -172,4 +172,4 @@ namespace Ryujinx.Audio
             0.707f,
         };
     }
-}
+}

Ryujinx.Audio/Input/AudioInputManager.cs

@@ -214,9 +214,9 @@ namespace Ryujinx.Audio.Input
                 outputDeviceName = audioIn.DeviceName;
                 outputConfiguration = new AudioOutputConfiguration
                 {
-                    ChannelCount  = audioIn.ChannelCount,
-                    SampleFormat  = audioIn.SampleFormat,
-                    SampleRate    = audioIn.SampleRate,
+                    ChannelCount = audioIn.ChannelCount,
+                    SampleFormat = audioIn.SampleFormat,
+                    SampleRate = audioIn.SampleRate,
                     AudioOutState = audioIn.GetState(),
                 };
 
@@ -263,4 +263,4 @@ namespace Ryujinx.Audio.Input
             }
         }
     }
-}
+}

Ryujinx.Audio/Input/AudioInputSystem.cs

@@ -389,4 +389,4 @@ namespace Ryujinx.Audio.Input
             }
         }
     }
-}
+}

Ryujinx.Audio/Integration/HardwareDeviceImpl.cs

@@ -32,8 +32,8 @@ namespace Ryujinx.Audio.Integration
             _session.QueueBuffer(new AudioBuffer
             {
                 DataPointer = _currentBufferTag++,
-                Data        = _buffer,
-                DataSize    = (ulong)_buffer.Length,
+                Data = _buffer,
+                DataSize = (ulong)_buffer.Length,
             });
 
             _currentBufferTag = _currentBufferTag % 4;
@@ -72,4 +72,4 @@ namespace Ryujinx.Audio.Integration
             }
         }
     }
-}
+}

Ryujinx.Audio/Integration/IHardwareDevice.cs

@@ -52,4 +52,4 @@ namespace Ryujinx.Audio.Integration
             return channelCount != Constants.ChannelCountMax;
         }
     }
-}
+}

Ryujinx.Audio/Integration/IHardwareDeviceDriver.cs

@@ -31,4 +31,4 @@ namespace Ryujinx.Audio.Integration
             return this;
         }
     }
-}
+}

Ryujinx.Audio/Integration/IHardwareDeviceSession.cs

@@ -25,4 +25,4 @@ namespace Ryujinx.Audio.Integration
 
         void PrepareToClose();
     }
-}
+}

Ryujinx.Audio/Integration/IWritableEvent.cs

@@ -15,4 +15,4 @@ namespace Ryujinx.Audio.Integration
         /// </summary>
         void Clear();
     }
-}
+}

Ryujinx.Audio/Output/AudioOutputManager.cs

@@ -209,9 +209,9 @@ namespace Ryujinx.Audio.Output
                 outputDeviceName = audioOut.DeviceName;
                 outputConfiguration = new AudioOutputConfiguration
                 {
-                    ChannelCount  = audioOut.ChannelCount,
-                    SampleFormat  = audioOut.SampleFormat,
-                    SampleRate    = audioOut.SampleRate,
+                    ChannelCount = audioOut.ChannelCount,
+                    SampleFormat = audioOut.SampleFormat,
+                    SampleRate = audioOut.SampleRate,
                     AudioOutState = audioOut.GetState(),
                 };
 
@@ -293,4 +293,4 @@ namespace Ryujinx.Audio.Output
             }
         }
     }
-}
+}

Ryujinx.Audio/Output/AudioOutputSystem.cs

@@ -169,7 +169,7 @@ namespace Ryujinx.Audio.Output
                 }
 
                 SampleFormat = sampleFormat;
-                SampleRate   = Constants.TargetSampleRate;
+                SampleRate = Constants.TargetSampleRate;
             }
 
             return result;
@@ -187,9 +187,9 @@ namespace Ryujinx.Audio.Output
             {
                 AudioBuffer buffer = new AudioBuffer
                 {
-                    BufferTag   = bufferTag,
+                    BufferTag = bufferTag,
                     DataPointer = userBuffer.Data,
-                    DataSize    = userBuffer.DataSize
+                    DataSize = userBuffer.DataSize
                 };
 
                 if (_session.AppendBuffer(buffer))
@@ -291,7 +291,7 @@ namespace Ryujinx.Audio.Output
         {
             lock (_parentLock)
             {
-                 _session.SetVolume(volume);
+                _session.SetVolume(volume);
             }
         }
 
@@ -362,4 +362,4 @@ namespace Ryujinx.Audio.Output
             }
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/AuxiliaryBufferAddresses.cs

@@ -10,4 +10,4 @@ namespace Ryujinx.Audio.Renderer.Common
         public ulong ReturnBufferInfo;
         public ulong ReturnBufferInfoBase;
     }
-}
+}

Ryujinx.Audio/Renderer/Common/BehaviourParameter.cs

@@ -47,4 +47,4 @@ namespace Ryujinx.Audio.Renderer.Common
             public ulong ExtraErrorInfo;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/EdgeMatrix.cs

@@ -147,4 +147,4 @@ namespace Ryujinx.Audio.Renderer.Common
             return _nodeCount;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/EffectType.cs

@@ -50,4 +50,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         CaptureBuffer
     }
-}
+}

Ryujinx.Audio/Renderer/Common/MemoryPoolUserState.cs

@@ -40,4 +40,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         Released = 6
     }
-}
+}

Ryujinx.Audio/Renderer/Common/NodeIdHelper.cs

@@ -25,4 +25,4 @@ namespace Ryujinx.Audio.Renderer.Common
             return (nodeId >> 16) & 0xFFF;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/NodeIdType.cs

@@ -30,4 +30,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         Performance = 15
     }
-}
+}

Ryujinx.Audio/Renderer/Common/NodeStates.cs

@@ -226,4 +226,4 @@ namespace Ryujinx.Audio.Renderer.Common
             return true;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/PerformanceDetailType.cs

@@ -16,4 +16,4 @@ namespace Ryujinx.Audio.Renderer.Common
         Limiter,
         CaptureBuffer
     }
-}
+}

Ryujinx.Audio/Renderer/Common/PerformanceEntryType.cs

@@ -8,4 +8,4 @@ namespace Ryujinx.Audio.Renderer.Common
         FinalMix,
         Sink
     }
-}
+}

Ryujinx.Audio/Renderer/Common/PlayState.cs

@@ -20,4 +20,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         Pause
     }
-}
+}

Ryujinx.Audio/Renderer/Common/ReverbEarlyMode.cs

@@ -30,4 +30,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         Disabled
     }
-}
+}

Ryujinx.Audio/Renderer/Common/ReverbLateMode.cs

@@ -35,4 +35,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         Limit = NoDelay
     }
-}
+}

Ryujinx.Audio/Renderer/Common/SinkType.cs

@@ -20,4 +20,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         CircularBuffer
     }
-}
+}

Ryujinx.Audio/Renderer/Common/UpdateDataHeader.cs

@@ -30,4 +30,4 @@ namespace Ryujinx.Audio.Renderer.Common
             TotalSize = (uint)Unsafe.SizeOf<UpdateDataHeader>();
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/VoiceUpdateState.cs

@@ -101,4 +101,4 @@ namespace Ryujinx.Audio.Renderer.Common
             }
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Common/WaveBuffer.cs

@@ -79,4 +79,4 @@ namespace Ryujinx.Audio.Renderer.Common
         /// </summary>
         private ushort _padding;
     }
-}
+}

Ryujinx.Audio/Renderer/Common/WorkBufferAllocator.cs

@@ -41,7 +41,7 @@ namespace Ryujinx.Audio.Renderer.Common
             return Memory<byte>.Empty;
         }
 
-        public Memory<T> Allocate<T>(ulong count, int align) where T: unmanaged
+        public Memory<T> Allocate<T>(ulong count, int align) where T : unmanaged
         {
             Memory<byte> allocatedMemory = Allocate((ulong)Unsafe.SizeOf<T>() * count, align);
 
@@ -53,9 +53,9 @@ namespace Ryujinx.Audio.Renderer.Common
             return SpanMemoryManager<T>.Cast(allocatedMemory);
         }
 
-        public static ulong GetTargetSize<T>(ulong currentSize, ulong count, int align) where T: unmanaged
+        public static ulong GetTargetSize<T>(ulong currentSize, ulong count, int align) where T : unmanaged
         {
             return BitUtils.AlignUp(currentSize, align) + (ulong)Unsafe.SizeOf<T>() * count;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Device/VirtualDevice.cs

@@ -86,4 +86,4 @@ namespace Ryujinx.Audio.Renderer.Device
             return Name;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Device/VirtualDeviceSession.cs

@@ -24,4 +24,4 @@ namespace Ryujinx.Audio.Renderer.Device
             Device = virtualDevice;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Device/VirtualDeviceSessionRegistry.cs

@@ -59,4 +59,4 @@ namespace Ryujinx.Audio.Renderer.Device
             return virtualDeviceSession;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/AdpcmHelper.cs

@@ -199,4 +199,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return decodedCount;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/AudioProcessor.cs

@@ -268,4 +268,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/BiquadFilterHelper.cs

@@ -80,4 +80,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
         }
     }
-}
+}

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

@@ -72,4 +72,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);
         }
     }
-}
+}

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

@@ -170,4 +170,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -49,4 +49,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             BiquadFilterHelper.ProcessBiquadFilter(ref _parameter, ref state, outputBuffer, inputBuffer, context.SampleCount);
         }
     }
-}
+}

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

@@ -134,4 +134,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -74,4 +74,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -21,4 +21,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             context.ClearBuffers();
         }
     }
-}
+}

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

@@ -153,4 +153,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             _buffersMemoryHandle.Dispose();
         }
     }
-}
+}

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

@@ -33,4 +33,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         GroupedBiquadFilter,
         CaptureBuffer
     }
-}
+}

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

@@ -29,4 +29,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             context.CopyBuffer(OutputBufferIndex, InputBufferIndex);
         }
     }
-}
+}

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

@@ -105,4 +105,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);
         }
     }
-}
+}

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

@@ -87,7 +87,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
             float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
 
-            Matrix2x2 delayFeedback = new Matrix2x2(delayFeedbackBaseGain , delayFeedbackCrossGain,
+            Matrix2x2 delayFeedback = new Matrix2x2(delayFeedbackBaseGain, delayFeedbackCrossGain,
                                                     delayFeedbackCrossGain, delayFeedbackBaseGain);
 
             for (int i = 0; i < sampleCount; i++)
@@ -124,10 +124,10 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
             float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
 
-            Matrix4x4 delayFeedback = new Matrix4x4(delayFeedbackBaseGain , delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f,
-                                                    delayFeedbackCrossGain, delayFeedbackBaseGain , 0.0f                  , delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, 0.0f                  , delayFeedbackBaseGain , delayFeedbackCrossGain,
-                                                    0.0f                  , delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);
+            Matrix4x4 delayFeedback = new Matrix4x4(delayFeedbackBaseGain, delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f,
+                                                    delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain,
+                                                    delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
+                                                    0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);
 
 
             for (int i = 0; i < sampleCount; i++)
@@ -149,7 +149,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                 };
 
                 Vector4 temp = MatrixHelper.Transform(ref channelInput, ref delayFeedback) + channelInput * inGain;
-                
+
                 state.UpdateLowPassFilter(ref Unsafe.As<Vector4, float>(ref temp), channelCount);
 
                 *((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;
@@ -171,12 +171,12 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
             float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
 
-            Matrix6x6 delayFeedback = new Matrix6x6(delayFeedbackBaseGain , 0.0f                  , 0.0f                  , 0.0f                  , delayFeedbackCrossGain, delayFeedbackCrossGain,
-                                                    0.0f                  , delayFeedbackBaseGain , 0.0f                  , delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f                  ,
-                                                    delayFeedbackCrossGain, 0.0f                  , delayFeedbackBaseGain , delayFeedbackCrossGain, 0.0f                  , 0.0f                  ,
-                                                    0.0f                  , delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain , 0.0f                  , 0.0f                  ,
-                                                    delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f                  , 0.0f                  , delayFeedbackBaseGain , 0.0f                  ,
-                                                    0.0f                  , 0.0f                  , 0.0f                  , 0.0f                  , 0.0f                  , feedbackGain);
+            Matrix6x6 delayFeedback = new Matrix6x6(delayFeedbackBaseGain, 0.0f, 0.0f, 0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain,
+                                                    0.0f, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f,
+                                                    delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain, 0.0f, 0.0f,
+                                                    0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, 0.0f,
+                                                    delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackBaseGain, 0.0f,
+                                                    0.0f, 0.0f, 0.0f, 0.0f, 0.0f, feedbackGain);
 
             for (int i = 0; i < sampleCount; i++)
             {
@@ -277,4 +277,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessDelay(context, ref state);
         }
     }
-}
+}

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

@@ -90,4 +90,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -54,4 +54,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -88,4 +88,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -65,4 +65,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             context.ClearBuffer(OutputBufferIndices[5]);
         }
     }
-}
+}

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

@@ -60,4 +60,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -17,4 +17,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             return false;
         }
     }
-}
+}

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

@@ -143,4 +143,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -162,4 +162,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -134,4 +134,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessMix(outputBuffer, inputBuffer);
         }
     }
-}
+}

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

@@ -65,4 +65,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             State.Span[0].LastSamples[LastSampleIndex] = ProcessMixRamp(outputBuffer, inputBuffer, (int)context.SampleCount);
         }
     }
-}
+}

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

@@ -88,4 +88,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -71,4 +71,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);
         }
     }
-}
+}

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

@@ -71,4 +71,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);
         }
     }
-}
+}

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

@@ -44,4 +44,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -251,4 +251,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessReverb3d(context, ref state);
         }
     }
-}
+}

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

@@ -276,4 +276,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessReverb(context, ref state);
         }
     }
-}
+}

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

@@ -66,4 +66,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
         }
     }
-}
+}

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

@@ -134,4 +134,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessVolume(outputBuffer, inputBuffer);
         }
     }
-}
+}

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

@@ -53,4 +53,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ProcessVolumeRamp(outputBuffer, inputBuffer, (int)context.SampleCount);
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/DataSourceHelper.cs

@@ -463,4 +463,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
         }
     }
-}
+}

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

@@ -49,4 +49,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Effect
             return _delayLine.Tap(sampleIndex);
         }
     }
-}
+}

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

@@ -75,4 +75,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Effect
             return TapUnsafe(sampleIndex, -1);
         }
     }
-}
+}

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

@@ -73,4 +73,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Effect
             return TapUnsafe(sampleIndex, -1);
         }
     }
-}
+}

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

@@ -34,4 +34,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.Effect
             return (uint)MathF.Round(sampleRate * delayTime);
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/FixedPointHelper.cs

@@ -30,4 +30,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return ToInt(value + half, qBits);
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/FloatingPointHelper.cs

@@ -64,4 +64,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return MathF.Sin(DegreesToRadians(value));
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/PcmHelper.cs

@@ -75,4 +75,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return (short)value;
         }
     }
-}
+}

Ryujinx.Audio/Renderer/Dsp/ResamplerHelper.cs

@@ -627,4 +627,4 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
         }
     }
-}
+}

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

@@ -9,4 +9,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
         public short History0;
         public short History1;
     }
-}
+}

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

@@ -71,4 +71,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
         public AuxiliaryBufferInfo CpuBufferInfo;
         public AuxiliaryBufferInfo DspBufferInfo;
     }
-}
+}

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

@@ -10,4 +10,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
         public float State2;
         public float State3;
     }
-}
+}

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

@@ -64,4 +64,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
             }
         }
     }
-}
+}

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

@@ -25,6 +25,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
             UpdateParameter(ref parameter);
         }
 
-        public void UpdateParameter(ref LimiterParameter parameter) {}
+        public void UpdateParameter(ref LimiterParameter parameter) { }
     }
-}
+}

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

@@ -116,4 +116,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
             }
         }
     }
-}
+}

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

@@ -201,4 +201,4 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
             }
         }
     }
-}
+}