diff options
Diffstat (limited to 'Ryujinx.Audio/Renderer/Utils')
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/AudioProcessorMemoryManager.cs | 75 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/BitArray.cs | 120 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/FileHardwareDevice.cs | 105 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/Mailbox.cs | 72 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/SpanIOHelper.cs | 188 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/SpanMemoryManager.cs | 60 | ||||
| -rw-r--r-- | Ryujinx.Audio/Renderer/Utils/SplitterHardwareDevice.cs | 64 |
7 files changed, 684 insertions, 0 deletions
diff --git a/Ryujinx.Audio/Renderer/Utils/AudioProcessorMemoryManager.cs b/Ryujinx.Audio/Renderer/Utils/AudioProcessorMemoryManager.cs new file mode 100644 index 00000000..99cbfcdc --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/AudioProcessorMemoryManager.cs @@ -0,0 +1,75 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using System.Runtime.CompilerServices; + +using DspAddress = System.UInt64; +using CpuAddress = System.UInt64; + +namespace Ryujinx.Audio.Renderer.Utils +{ + /// <summary> + /// The <see cref="Dsp.AudioProcessor"/> memory management + /// </summary> + /// <remarks>This is stub for the most part but is kept to permit LLE if wanted.</remarks> + static class AudioProcessorMemoryManager + { + /// <summary> + /// Map the given <see cref="CpuAddress"/> to the <see cref="Dsp.AudioProcessor"/> address space. + /// </summary> + /// <param name="processHandle">The process owning the CPU memory.</param> + /// <param name="cpuAddress">The <see cref="CpuAddress"/> to map.</param> + /// <param name="size">The size of the CPU memory region to map.</param> + /// <returns>The address on the <see cref="Dsp.AudioProcessor"/> address space.</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static DspAddress Map(uint processHandle, CpuAddress cpuAddress, ulong size) + { + return cpuAddress; + } + + /// <summary> + /// Unmap the given <see cref="CpuAddress"/> from the <see cref="Dsp.AudioProcessor"/> address space. + /// </summary> + /// <param name="processHandle">The process owning the CPU memory.</param> + /// <param name="cpuAddress">The <see cref="CpuAddress"/> to unmap.</param> + /// <param name="size">The size of the CPU memory region to unmap.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void Unmap(uint processHandle, CpuAddress cpuAddress, ulong size) + { + } + + /// <summary> + /// Invalidate the <see cref="Dsp.AudioProcessor"/> data cache at the given address. + /// </summary> + /// <param name="address">The base DSP address to invalidate</param> + /// <param name="size">The size of the DSP memory region to invalidate.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void InvalidateDspCache(DspAddress address, ulong size) + { + } + + /// <summary> + /// Invalidate the CPU data cache at the given address. + /// </summary> + /// <param name="address">The base <see cref="CpuAddress"/> to invalidate</param> + /// <param name="size">The size of the CPU memory region to invalidate.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void InvalidateDataCache(CpuAddress address, ulong size) + { + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/BitArray.cs b/Ryujinx.Audio/Renderer/Utils/BitArray.cs new file mode 100644 index 00000000..6109dd01 --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/BitArray.cs @@ -0,0 +1,120 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using System; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Audio.Renderer.Utils +{ + /// <summary> + /// A simple bit array implementation backed by a <see cref="Memory{T}"/>. + /// </summary> + public class BitArray + { + /// <summary> + /// The backing storage of the <see cref="BitArray"/>. + /// </summary> + private Memory<byte> _storage; + + /// <summary> + /// Create a new <see cref="BitArray"/> from <see cref="Memory{T}"/>. + /// </summary> + /// <param name="storage">The backing storage of the <see cref="BitArray"/>.</param> + public BitArray(Memory<byte> storage) + { + _storage = storage; + } + + /// <summary> + /// Get the byte position of a given bit index. + /// </summary> + /// <param name="index">A bit index.</param> + /// <returns>The byte position of a given bit index.</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ToPosition(int index) => index / 8; + + /// <summary> + /// Get the bit position of a given bit index inside a byte. + /// </summary> + /// <param name="index">A bit index.</param> + /// <returns>The bit position of a given bit index inside a byte.</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ToBitPosition(int index) => index % 8; + + /// <summary> + /// Test if the bit at the given index is set. + /// </summary> + /// <param name="index">A bit index.</param> + /// <returns>Return true if the bit at the given index is set</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Test(int index) + { + ulong mask = 1ul << ToBitPosition(index); + + return (_storage.Span[ToPosition(index)] & mask) == mask; + } + + /// <summary> + /// Set the bit at the given index. + /// </summary> + /// <param name="index">A bit index.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Set(int index) + { + Set(index, true); + } + + /// <summary> + /// Reset the bit at the given index. + /// </summary> + /// <param name="index">A bit index.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Reset(int index) + { + Set(index, false); + } + + /// <summary> + /// Set a bit value at the given index. + /// </summary> + /// <param name="index">A bit index.</param> + /// <param name="value">The new bit value.</param> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void Set(int index, bool value) + { + byte mask = (byte)(1 << ToBitPosition(index)); + + if (value) + { + _storage.Span[ToPosition(index)] |= mask; + } + else + { + _storage.Span[ToPosition(index)] &= (byte)~mask; + } + } + + /// <summary> + /// Reset all bits in the storage. + /// </summary> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Reset() + { + _storage.Span.Fill(0); + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/FileHardwareDevice.cs b/Ryujinx.Audio/Renderer/Utils/FileHardwareDevice.cs new file mode 100644 index 00000000..2008bafc --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/FileHardwareDevice.cs @@ -0,0 +1,105 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using Ryujinx.Audio.Integration; +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; + +namespace Ryujinx.Audio.Renderer.Utils +{ + /// <summary> + /// A <see cref="IHardwareDevice"/> that outputs to a wav file. + /// </summary> + public class FileHardwareDevice : IHardwareDevice + { + private FileStream _stream; + private uint _channelCount; + private uint _sampleRate; + + private const int HeaderSize = 44; + + public FileHardwareDevice(string path, uint channelCount, uint sampleRate) + { + _stream = File.OpenWrite(path); + _channelCount = channelCount; + _sampleRate = sampleRate; + + _stream.Seek(HeaderSize, SeekOrigin.Begin); + } + + private void UpdateHeader() + { + var writer = new BinaryWriter(_stream); + + long currentPos = writer.Seek(0, SeekOrigin.Current); + + writer.Seek(0, SeekOrigin.Begin); + + writer.Write(Encoding.ASCII.GetBytes("RIFF")); + writer.Write((int)(writer.BaseStream.Length - 8)); + writer.Write(Encoding.ASCII.GetBytes("WAVE")); + writer.Write(Encoding.ASCII.GetBytes("fmt ")); + writer.Write(16); + writer.Write((short)1); + writer.Write((short)GetChannelCount()); + writer.Write(GetSampleRate()); + writer.Write(GetSampleRate() * GetChannelCount() * sizeof(short)); + writer.Write((short)(GetChannelCount() * sizeof(short))); + writer.Write((short)(sizeof(short) * 8)); + writer.Write(Encoding.ASCII.GetBytes("data")); + writer.Write((int)(writer.BaseStream.Length - HeaderSize)); + + writer.Seek((int)currentPos, SeekOrigin.Begin); + } + + public void AppendBuffer(ReadOnlySpan<short> data, uint channelCount) + { + _stream.Write(MemoryMarshal.Cast<short, byte>(data)); + + UpdateHeader(); + _stream.Flush(); + } + + public uint GetChannelCount() + { + return _channelCount; + } + + public uint GetSampleRate() + { + return _sampleRate; + } + + public void Dispose() + { + Dispose(true); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _stream?.Flush(); + _stream?.Dispose(); + + _stream = null; + } + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/Mailbox.cs b/Ryujinx.Audio/Renderer/Utils/Mailbox.cs new file mode 100644 index 00000000..a32de870 --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/Mailbox.cs @@ -0,0 +1,72 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Concurrent; + +namespace Ryujinx.Audio.Renderer.Utils +{ + /// <summary> + /// A simple generic message queue for unmanaged types. + /// </summary> + /// <typeparam name="T">The target unmanaged type used</typeparam> + public class Mailbox<T> : IDisposable where T : unmanaged + { + private BlockingCollection<T> _messageQueue; + private BlockingCollection<T> _responseQueue; + + public Mailbox() + { + _messageQueue = new BlockingCollection<T>(1); + _responseQueue = new BlockingCollection<T>(1); + } + + public void SendMessage(T data) + { + _messageQueue.Add(data); + } + + public void SendResponse(T data) + { + _responseQueue.Add(data); + } + + public T ReceiveMessage() + { + return _messageQueue.Take(); + } + + public T ReceiveResponse() + { + return _responseQueue.Take(); + } + + public void Dispose() + { + Dispose(true); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _messageQueue.Dispose(); + _responseQueue.Dispose(); + } + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/SpanIOHelper.cs b/Ryujinx.Audio/Renderer/Utils/SpanIOHelper.cs new file mode 100644 index 00000000..70a2fce6 --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/SpanIOHelper.cs @@ -0,0 +1,188 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Ryujinx.Audio.Renderer.Utils +{ + /// <summary> + /// Helper for IO operations on <see cref="Span{T}"/> and <see cref="Memory{T}"/>. + /// </summary> + public static class SpanIOHelper + { + /// <summary> + /// Write the given data to the given backing <see cref="Memory{T}"/> and move cursor after the written data. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="Memory{T}"/> to store the data.</param> + /// <param name="data">The data to write to the backing <see cref="Memory{T}"/>.</param> + public static void Write<T>(ref Memory<byte> backingMemory, ref T data) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + MemoryMarshal.Write<T>(backingMemory.Span.Slice(0, size), ref data); + + backingMemory = backingMemory.Slice(size); + } + + /// <summary> + /// Write the given data to the given backing <see cref="Span{T}"/> and move cursor after the written data. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="Span{T}"/> to store the data.</param> + /// <param name="data">The data to write to the backing <see cref="Span{T}"/>.</param> + public static void Write<T>(ref Span<byte> backingMemory, ref T data) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + MemoryMarshal.Write<T>(backingMemory.Slice(0, size), ref data); + + backingMemory = backingMemory.Slice(size); + } + + /// <summary> + /// Get a <see cref="Span{T}"/> out of a <paramref name="backingMemory"/> and move cursor after T size. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="Memory{T}"/> to get a <see cref="Span{T}"/> from.</param> + /// <returns>A <see cref="Span{T}"/> from backing <see cref="Memory{T}"/>.</returns> + public static Span<T> GetWriteRef<T>(ref Memory<byte> backingMemory) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + Span<T> result = MemoryMarshal.Cast<byte, T>(backingMemory.Span.Slice(0, size)); + + backingMemory = backingMemory.Slice(size); + + return result; + } + + /// <summary> + /// Get a <see cref="Span{T}"/> out of a backingMemory and move cursor after T size. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="Span{T}"/> to get a <see cref="Span{T}"/> from.</param> + /// <returns>A <see cref="Span{T}"/> from backing <see cref="Span{T}"/>.</returns> + public static Span<T> GetWriteRef<T>(ref Span<byte> backingMemory) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + Span<T> result = MemoryMarshal.Cast<byte, T>(backingMemory.Slice(0, size)); + + backingMemory = backingMemory.Slice(size); + + return result; + } + + /// <summary> + /// Read data from the given backing <see cref="ReadOnlyMemory{T}"/> and move cursor after the read data. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="ReadOnlyMemory{T}"/> to read data from.</param> + /// <returns>Return the read data.</returns> + public static T Read<T>(ref ReadOnlyMemory<byte> backingMemory) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + T result = MemoryMarshal.Read<T>(backingMemory.Span.Slice(0, size)); + + backingMemory = backingMemory.Slice(size); + + return result; + } + + /// <summary> + /// Read data from the given backing <see cref="ReadOnlySpan{T}"/> and move cursor after the read data. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="backingMemory">The backing <see cref="ReadOnlySpan{T}"/> to read data from.</param> + /// <returns>Return the read data.</returns> + public static T Read<T>(ref ReadOnlySpan<byte> backingMemory) where T : unmanaged + { + int size = Unsafe.SizeOf<T>(); + + if (size > backingMemory.Length) + { + throw new ArgumentOutOfRangeException(); + } + + T result = MemoryMarshal.Read<T>(backingMemory.Slice(0, size)); + + backingMemory = backingMemory.Slice(size); + + return result; + } + + /// <summary> + /// Extract a <see cref="Memory{T}"/> at the given index. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="memory">The <see cref="Memory{T}"/> to extract the data from.</param> + /// <param name="id">The id in the provided memory.</param> + /// <param name="count">The max allowed count. (for bound checking of the id in debug mode)</param> + /// <returns>a <see cref="Memory{T}"/> at the given id.</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Memory<T> GetMemory<T>(Memory<T> memory, int id, uint count) where T : unmanaged + { + Debug.Assert(id >= 0 && id < count); + + return memory.Slice(id, 1); + } + + /// <summary> + /// Extract a ref T at the given index. + /// </summary> + /// <typeparam name="T">The data type.</typeparam> + /// <param name="memory">The <see cref="Memory{T}"/> to extract the data from.</param> + /// <param name="id">The id in the provided memory.</param> + /// <param name="count">The max allowed count. (for bound checking of the id in debug mode)</param> + /// <returns>a ref T at the given id.</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ref T GetFromMemory<T>(Memory<T> memory, int id, uint count) where T : unmanaged + { + return ref GetMemory(memory, id, count).Span[0]; + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/SpanMemoryManager.cs b/Ryujinx.Audio/Renderer/Utils/SpanMemoryManager.cs new file mode 100644 index 00000000..102a9f95 --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/SpanMemoryManager.cs @@ -0,0 +1,60 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using System; +using System.Buffers; +using System.Runtime.InteropServices; + +namespace Ryujinx.Audio.Renderer.Utils +{ + public sealed unsafe class SpanMemoryManager<T> : MemoryManager<T> + where T : unmanaged + { + private readonly T* _pointer; + private readonly int _length; + + public SpanMemoryManager(Span<T> span) + { + fixed (T* ptr = &MemoryMarshal.GetReference(span)) + { + _pointer = ptr; + _length = span.Length; + } + } + + public override Span<T> GetSpan() => new Span<T>(_pointer, _length); + + public override MemoryHandle Pin(int elementIndex = 0) + { + if (elementIndex < 0 || elementIndex >= _length) + { + throw new ArgumentOutOfRangeException(nameof(elementIndex)); + } + + return new MemoryHandle(_pointer + elementIndex); + } + + public override void Unpin() { } + + protected override void Dispose(bool disposing) { } + + public static Memory<T> Cast<TFrom>(Memory<TFrom> memory) where TFrom : unmanaged + { + return new SpanMemoryManager<T>(MemoryMarshal.Cast<TFrom, T>(memory.Span)).Memory; + } + } +} diff --git a/Ryujinx.Audio/Renderer/Utils/SplitterHardwareDevice.cs b/Ryujinx.Audio/Renderer/Utils/SplitterHardwareDevice.cs new file mode 100644 index 00000000..c5411ac0 --- /dev/null +++ b/Ryujinx.Audio/Renderer/Utils/SplitterHardwareDevice.cs @@ -0,0 +1,64 @@ +// +// Copyright (c) 2019-2021 Ryujinx +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. +// + +using Ryujinx.Audio.Integration; +using System; + +namespace Ryujinx.Audio.Renderer.Utils +{ + public class SplitterHardwareDevice : IHardwareDevice + { + private IHardwareDevice _baseDevice; + private IHardwareDevice _secondaryDevice; + + public SplitterHardwareDevice(IHardwareDevice baseDevice, IHardwareDevice secondaryDevice) + { + _baseDevice = baseDevice; + _secondaryDevice = secondaryDevice; + } + + public void AppendBuffer(ReadOnlySpan<short> data, uint channelCount) + { + _baseDevice.AppendBuffer(data, channelCount); + _secondaryDevice?.AppendBuffer(data, channelCount); + } + + public uint GetChannelCount() + { + return _baseDevice.GetChannelCount(); + } + + public uint GetSampleRate() + { + return _baseDevice.GetSampleRate(); + } + + public void Dispose() + { + Dispose(true); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _baseDevice.Dispose(); + _secondaryDevice?.Dispose(); + } + } + } +} |