From 8275bc3c087830baf84ef7ac236fade24988b522 Mon Sep 17 00:00:00 2001
From: jduncanator <jduncanator@users.noreply.github.com>
Date: Thu, 15 Nov 2018 13:22:50 +1100
Subject: [PATCH] Implement libsoundio as an alternative audio backend (#406)
* Audio: Implement libsoundio as an alternative audio backend
libsoundio will be preferred over OpenAL if it is available on the machine. If neither are available, it will fallback to a dummy audio renderer that outputs no sound.
* Audio: Fix SoundIoRingBuffer documentation
* Audio: Unroll and optimize the audio write callback
Copying one sample at a time is slow, this unrolls the most common audio channel layouts and manually copies the bytes between source and destination. This is over 2x faster than calling CopyBlockUnaligned every sample.
* Audio: Optimize the write callback further
This dramatically reduces the audio buffer copy time. When the sample size is one of handled sample sizes the buffer copy operation is almost 10x faster than CopyBlockAligned.
This works by copying full samples at a time, rather than the individual bytes that make up the sample. This allows for 2x or 4x faster copy operations depending on sample size.
* Audio: Fix typo in Stereo write callback
* Audio: Fix Surround (5.1) audio write callback
* Audio: Update Documentation
* Audio: Use built-in Unsafe.SizeOf<T>()
Built-in `SizeOf<T>()` is 10x faster than our `TypeSize<T>` helper. This also helps reduce code surface area.
* Audio: Keep fixed buffer style consistent
* Audio: Address styling nits
* Audio: More style nits
* Audio: Add additional documentation
* Audio: Move libsoundio bindings internal
As per discussion, moving the libsoundio native bindings into Ryujinx.Audio
* Audio: Bump Target Framework back up to .NET Core 2.1
* Audio: Remove voice mixing optimizations.
Leaves Saturation optimizations in place.
---
.../{ => Decoders}/Adpcm/AdpcmDecoder.cs | 0
.../Adpcm/AdpcmDecoderContext.cs | 0
Ryujinx.Audio/IAalOutput.cs | 16 +-
.../Native/libsoundio/MarshalExtensions.cs | 23 +
Ryujinx.Audio/Native/libsoundio/SoundIO.cs | 311 +++++++++
.../Native/libsoundio/SoundIOBackend.cs | 15 +
.../Native/libsoundio/SoundIOChannelArea.cs | 26 +
.../Native/libsoundio/SoundIOChannelAreas.cs | 33 +
.../Native/libsoundio/SoundIOChannelId.cs | 77 +++
.../Native/libsoundio/SoundIOChannelLayout.cs | 99 +++
.../Native/libsoundio/SoundIODevice.cs | 215 ++++++
.../Native/libsoundio/SoundIODeviceAim.cs | 9 +
.../Native/libsoundio/SoundIOException.cs | 13 +
.../Native/libsoundio/SoundIOFormat.cs | 26 +
.../Native/libsoundio/SoundIOInStream.cs | 228 +++++++
.../Native/libsoundio/SoundIOOutStream.cs | 241 +++++++
.../Native/libsoundio/SoundIORingBuffer.cs | 61 ++
.../libsoundio/SoundIOSampleRateRange.cs | 15 +
.../Native/libsoundio/libs/libsoundio.dll | Bin 0 -> 370899 bytes
.../Native/libsoundio/libs/libsoundio.dylib | Bin 0 -> 106760 bytes
.../Native/libsoundio/libs/libsoundio.so | Bin 0 -> 265888 bytes
.../Native/libsoundio/libsoundio-interop.cs | 638 ++++++++++++++++++
Ryujinx.Audio/PlaybackState.cs | 9 +
Ryujinx.Audio/Renderers/DummyAudioOut.cs | 63 ++
.../{ => Renderers}/OpenAL/OpenALAudioOut.cs | 23 +-
.../Renderers/SoundIo/SoundIoAudioOut.cs | 189 ++++++
.../Renderers/SoundIo/SoundIoAudioTrack.cs | 560 +++++++++++++++
.../SoundIo/SoundIoAudioTrackPool.cs | 193 ++++++
.../Renderers/SoundIo/SoundIoBuffer.cs | 29 +
.../Renderers/SoundIo/SoundIoRingBuffer.cs | 204 ++++++
Ryujinx.Audio/Ryujinx.Audio.csproj | 24 +
.../Aud/AudioRenderer/IAudioRenderer.cs | 56 +-
Ryujinx/{Ui => }/Program.cs | 23 +-
Ryujinx/Ryujinx.csproj | 1 -
34 files changed, 3399 insertions(+), 21 deletions(-)
rename Ryujinx.Audio/{ => Decoders}/Adpcm/AdpcmDecoder.cs (100%)
rename Ryujinx.Audio/{ => Decoders}/Adpcm/AdpcmDecoderContext.cs (100%)
create mode 100644 Ryujinx.Audio/Native/libsoundio/MarshalExtensions.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIO.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOBackend.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOChannelArea.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOChannelId.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOChannelLayout.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIODevice.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIODeviceAim.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOException.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOFormat.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOInStream.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOOutStream.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIORingBuffer.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/SoundIOSampleRateRange.cs
create mode 100644 Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dll
create mode 100644 Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dylib
create mode 100644 Ryujinx.Audio/Native/libsoundio/libs/libsoundio.so
create mode 100644 Ryujinx.Audio/Native/libsoundio/libsoundio-interop.cs
create mode 100644 Ryujinx.Audio/Renderers/DummyAudioOut.cs
rename Ryujinx.Audio/{ => Renderers}/OpenAL/OpenALAudioOut.cs (94%)
create mode 100644 Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
create mode 100644 Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrack.cs
create mode 100644 Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrackPool.cs
create mode 100644 Ryujinx.Audio/Renderers/SoundIo/SoundIoBuffer.cs
create mode 100644 Ryujinx.Audio/Renderers/SoundIo/SoundIoRingBuffer.cs
rename Ryujinx/{Ui => }/Program.cs (79%)
diff --git a/Ryujinx.Audio/Adpcm/AdpcmDecoder.cs b/Ryujinx.Audio/Decoders/Adpcm/AdpcmDecoder.cs
similarity index 100%
rename from Ryujinx.Audio/Adpcm/AdpcmDecoder.cs
rename to Ryujinx.Audio/Decoders/Adpcm/AdpcmDecoder.cs
diff --git a/Ryujinx.Audio/Adpcm/AdpcmDecoderContext.cs b/Ryujinx.Audio/Decoders/Adpcm/AdpcmDecoderContext.cs
similarity index 100%
rename from Ryujinx.Audio/Adpcm/AdpcmDecoderContext.cs
rename to Ryujinx.Audio/Decoders/Adpcm/AdpcmDecoderContext.cs
diff --git a/Ryujinx.Audio/IAalOutput.cs b/Ryujinx.Audio/IAalOutput.cs
index 1dfac377f7..119fc2342d 100644
--- a/Ryujinx.Audio/IAalOutput.cs
+++ b/Ryujinx.Audio/IAalOutput.cs
@@ -4,19 +4,19 @@ namespace Ryujinx.Audio
{
public interface IAalOutput : IDisposable
{
- int OpenTrack(int SampleRate, int Channels, ReleaseCallback Callback);
+ int OpenTrack(int sampleRate, int channels, ReleaseCallback callback);
- void CloseTrack(int Track);
+ void CloseTrack(int trackId);
- bool ContainsBuffer(int Track, long Tag);
+ bool ContainsBuffer(int trackId, long bufferTag);
- long[] GetReleasedBuffers(int Track, int MaxCount);
+ long[] GetReleasedBuffers(int trackId, int maxCount);
- void AppendBuffer<T>(int Track, long Tag, T[] Buffer) where T : struct;
+ void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct;
- void Start(int Track);
- void Stop(int Track);
+ void Start(int trackId);
+ void Stop(int trackId);
- PlaybackState GetState(int Track);
+ PlaybackState GetState(int trackId);
}
}
\ No newline at end of file
diff --git a/Ryujinx.Audio/Native/libsoundio/MarshalExtensions.cs b/Ryujinx.Audio/Native/libsoundio/MarshalExtensions.cs
new file mode 100644
index 0000000000..ec3eef3757
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/MarshalExtensions.cs
@@ -0,0 +1,23 @@
+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));
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIO.cs b/Ryujinx.Audio/Native/libsoundio/SoundIO.cs
new file mode 100644
index 0000000000..e9ab9e6e1a
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIO.cs
@@ -0,0 +1,311 @@
+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 (object)obj1 == null ? (object)obj2 == null : obj1.Equals (obj2);
+ }
+
+ public static bool operator != (SoundIO obj1, SoundIO obj2)
+ {
+ return (object)obj1 == null ? (object)obj2 != null : !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));
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOBackend.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOBackend.cs
new file mode 100644
index 0000000000..dfcb0a3f03
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOBackend.cs
@@ -0,0 +1,15 @@
+using System;
+namespace SoundIOSharp
+{
+ public enum SoundIOBackend
+ {
+ None = 0,
+ Jack = 1,
+ PulseAudio = 2,
+ Alsa = 3,
+ CoreAudio = 4,
+ Wasapi = 5,
+ Dummy = 6,
+ }
+
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOChannelArea.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelArea.cs
new file mode 100644
index 0000000000..f30e2bbb44
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelArea.cs
@@ -0,0 +1,26 @@
+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");
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs
new file mode 100644
index 0000000000..776d657acb
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs
@@ -0,0 +1,33 @@
+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;
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOChannelId.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelId.cs
new file mode 100644
index 0000000000..d24508a1f1
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelId.cs
@@ -0,0 +1,77 @@
+using System;
+namespace SoundIOSharp
+{
+
+ 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,
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOChannelLayout.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelLayout.cs
new file mode 100644
index 0000000000..ee63454200
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelLayout.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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);
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIODevice.cs b/Ryujinx.Audio/Native/libsoundio/SoundIODevice.cs
new file mode 100644
index 0000000000..81b78b679f
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIODevice.cs
@@ -0,0 +1,215 @@
+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 (object)obj1 == null ? (object)obj2 == null : obj1.Equals (obj2);
+ }
+
+ public static bool operator != (SoundIODevice obj1, SoundIODevice obj2)
+ {
+ return (object)obj1 == null ? (object) obj2 != null : !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 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));
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIODeviceAim.cs b/Ryujinx.Audio/Native/libsoundio/SoundIODeviceAim.cs
new file mode 100644
index 0000000000..9cd45f36f8
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIODeviceAim.cs
@@ -0,0 +1,9 @@
+using System;
+namespace SoundIOSharp
+{
+ public enum SoundIODeviceAim // soundio.h (228, 6)
+ {
+ Input = 0,
+ Output = 1,
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOException.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOException.cs
new file mode 100644
index 0000000000..ff6a0337b7
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOException.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SoundIOSharp
+{
+ public class SoundIOException : Exception
+ {
+ internal SoundIOException (SoundIoError errorCode)
+ : base (Marshal.PtrToStringAnsi (Natives.soundio_strerror ((int) errorCode)))
+ {
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOFormat.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOFormat.cs
new file mode 100644
index 0000000000..59434e1e57
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOFormat.cs
@@ -0,0 +1,26 @@
+using System;
+namespace SoundIOSharp
+{
+ 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,
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOInStream.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOInStream.cs
new file mode 100644
index 0000000000..fb0b310450
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOInStream.cs
@@ -0,0 +1,228 @@
+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 (object)obj1 == null ? (object)obj2 == null : obj1.Equals (obj2);
+ }
+
+ public static bool operator != (SoundIOInStream obj1, SoundIOInStream obj2)
+ {
+ return (object)obj1 == null ? (object)obj2 != null : !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 (IntPtr);
+ 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;
+ }
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOOutStream.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOOutStream.cs
new file mode 100644
index 0000000000..0b77e1af84
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOOutStream.cs
@@ -0,0 +1,241 @@
+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 (object)obj1 == null ? (object)obj2 == null : obj1.Equals (obj2);
+ }
+
+ public static bool operator != (SoundIOOutStream obj1, SoundIOOutStream obj2)
+ {
+ return (object)obj1 == null ? (object)obj2 != null : !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*)((IntPtr)handle + layout_offset), (void*)value.Handle,
+ 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");
+
+ // 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 (IntPtr);
+ 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;
+ }
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIORingBuffer.cs b/Ryujinx.Audio/Native/libsoundio/SoundIORingBuffer.cs
new file mode 100644
index 0000000000..63d796fd5b
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIORingBuffer.cs
@@ -0,0 +1,61 @@
+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);
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOSampleRateRange.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOSampleRateRange.cs
new file mode 100644
index 0000000000..28fee4585d
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/SoundIOSampleRateRange.cs
@@ -0,0 +1,15 @@
+using System;
+namespace SoundIOSharp
+{
+ public struct SoundIOSampleRateRange
+ {
+ internal SoundIOSampleRateRange (int min, int max)
+ {
+ Min = min;
+ Max = max;
+ }
+
+ public readonly int Min;
+ public readonly int Max;
+ }
+}
diff --git a/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dll b/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dll
new file mode 100644
index 0000000000000000000000000000000000000000..53a83f0f4525466728ec9bf37215f1304a20ee9b
GIT binary patch
literal 370899
zcmeEvdw5jU)%Oe}5F~KIB^oWrsIev%H1XD?ik%@7I0J(Qxrldclw#`zbw<%z2+jm@
zJPxK}tyXJkYrVBrTdiExNg_!A#Sj%iY7J`Z83T$~A>d`c-*4@6W+nrQ-}k=n^L>AO
z^E}DE@4eRAYp=cb-fQnO`NBq5Uzf|3gTG|b<yrxkKd=1%=6`ia9z1H*VArz)UO8rk
zJNU{m)8<@tqi607*Zug0%dhd&UViPh*M&Sky3%t)_*&0Z*LwWtPW4=K-4$1!G-%La
z#dg&-)h^c+i-x%dC%-$xbySXP)gYH^m+QNpfqnWM36INlt=r`q?s9bugTH`<a(>MJ
z;_sv2Mh;i53jzM(z@(qcHQ_(Gf|twXk!V$xUa2JIq+%M~uI&R5TIP0LoX=SMSL1g5
zXP^^++u?TI!v??R=ZU*rB?n2{^?SE#nGNDWl3gc-uACP_LeIzeM-YiS@W}kla@EW_
z>59ukmm{)5U<4q85!jQNi+wjMe$ovpW6ckcR)BnG!OiInIP!T<nyc~&j=<H$dcE2C
z%DgAdQ~B;8jb<VJFu1{k<onT$HzLIqXMfG@oz8gv>ImPJsy?B4qg~&O-ub;Qw0o7x
zCw+px5q#Nx#t-@8Csmy{jZriC?`foy*5sXxpV#G$pA@=U;G4tvxScNxPDQ^fufDF<
zrTV(V&UZt0eP!cLK20^?$%Wg6boN;&J73MXlgle5V{<;zcHwU@{%+0AS1|76Q_Ce^
zr7#gj=7|V4^ky8d3;9kvUGjOq52p<ID&YR@Ao)&b1~hpD{>??cBDf!B=kty``TJ$e
z=6aoipb`0qM<2KuKWVo@!B^ZDurEV8c`EN9`6^G5lDjaTT~DJ@@@YORPybk7I`sd2
z|2HTwRgdiOtaPCht@52Nmu@uaMvHZLBfMte$49zddi^%t=!3v+28=!-tvs%`Nr&r^
zmpm7>tRNFBuQtl%o9>%7{rnlMwxqr@V7xrpSR208%)RF_x2ry`Eg6N}5zDQcBX2-`
z<w+y=R;0Wjb(mwWUFvpq_g`tD`s5qB(X&g}{(7oj9}n-)&9PHZ!0aFC>7zyejV4!)
z!ar-r4$N6L1SJ<;df6qui+z{0%sxpQ6%}$u_PZrH{LYoSnR7gu9BuC@0xss<yz-=O
zj@frN8a+ZARmTE)WvdqLj|vY0#Czp?0LFThB^YikIuiNJ{y;1G8H(DGM<B9(j~4A@
zZD#J7(iF%T4-J}ZSgSbng2wh_M<jQ_rEZsk4&+M%Umj1KoJ=NXYoq+gY94<TY6zJ5
z#n#*<sIfk-8*4)og65dZC4REYn#p*hRgZj>r&oS<^Dy1)$L2m}M6v@>H|^Aogmrzl
z%N1zDe2ZV8EvJ}ndAzMZU43!i6$emJ8|76!lgLfMgU(;vH&L7lgE2}4!$Cvgw2^Wy
zYXVwI?EEU3RDGl~_)i3p`5z#UZVp-t$MPV)tv?Bp*nm{QH^n_3-8}t=$W`B|8?PF#
z1&y`F;o-~8+)0;^kwQPT&btd}7*;vb_gR1cjmzaTUaH>~%8h*9H(ZPa<1HrKi3BHr
z4A#Y8CX?W&zSZUL`;D%)en2EC%qy(Z(rA4SV#cbHP8sy`&A+q0E2To~omlI1R9hcM
zh2f(kpS#0<MS=q4i!YMN?muSmA5w!>zdHnqRYGDw)z2xe)!zgFQl&q7FaxJenSqB<
zZ(^j%D?CKxUPKPSAl>8eZ)ArKuKVNRZWma;jeYA19R>{b#P2}k#-QOZt}vz*pQanZ
z;u0%npt~Nsn|y|Nlkq0vCI9uzKV3Kel{uamrpVAEV|VRk-DP@g(DKhQUJE~2LTM2X
zovg<SpFs>{NwRQ<9XSBm;wS)qj1A&kM514k7}Ee>Ecad@*8Mj5O|{pU`n3pGr0J=f
zLv?e2IWDi#m$wR~lG=lD?YX#iZnMgno&Qi_k$=Mai*j8Txn0qCC|~%YMU6iQi@;rO
zSMoI=RY0U-`Yda20*EkXyd5JY5?zRn?9;Tx6am1>^`*;YtkY|UH|Xw;WS3xq=qL&S
zEG3^1UXT@Dm=(S!EByPc@MBrwN3+6z%nCoA6<(PYem*O_CM(>O6>iN6zmgT+m=)gK
zD~x%<*krAxbchWa`~?VSG+V6}ln_NPmHtPSKFm&kq*uE2CitLH_16mWL}cI4oAW{0
zq;!Cp)9`7E-c0%)l7{#08x&6U$LGD^i{)-aqp9*J`kSoue`bZB$O_+@6+S1czDu*h
zXJ>^2S>?0&r7kNyk`-Q*6<(YbZpaFoS>Yv_;mE#z+Tz6=zp>ma0O&#ZJ2wmdFEY!c
z*e6-x9a-V+S>bJ2;m)jZduBLe{-|H48?R{5p_pKF(^o^$)Q95d`5u68SbAGM*I4|)
zt5Y=78~LE8v?tb3gK&AgDbe>+{ZDPx9!WC8y3U!M%La2s9;T4;WPRs??<CeD*_OYN
zHg_QMQeNeoTI?xSXZD+Dj_^Q<3jHhcr+*;E9sY-IMhF4{%GHgnfXSScXLY{E?2`(t
zb>fLU%`CB{RLykL%%fA;5gM*nwudx`R_phYO%kkom4BHOiC`i|-lkBlHDA@~(PLF*
zD&}g&7+Y;HtxFIDDggJ+DHu5Bj3NiC!bBXkHD=%=0GZ<p9E9F?5ZZQdgxsp}0;}g;
zqHsurHc2*x&|2j`0HG%(eo_WP4=^T;(47bZ3nEklgmiPTb&Hfar@)#kSwFGnh?@|h
zEz^Et24a-_koll|n^k-yC;0G;Rb+&f_;Xo47DJzngW&(;K9N^ve@<uQa)ykWJl)U>
zAjRhFBS<wx$QP58nPo^R(Tx_wR^ZR88(Y*Q)0oAt8@1^BeMqegetkjsb(h|@D9x{n
zzL8(YdjKygnGb$V+WdOH@axV4_;sz~*Ebw~?eBE&q4@RK?Q8=4dZc&`*}c2Fm|u18
zzm<O(p^Rnl>qd#s?A|quLH8;!ttSyQ&(EuT!{*oXg<px4!>?(46u(aR*8Dm}HC|xp
z;yENj$4EAXP@(cKb7dj)<vT<=6QOR#q!IcDg68=}L`d<gX04Ml=N4FT$-2*4LAPzZ
zj>_rQ*zQc*on^aoY<I5h&QtE9I=c9Qff|&L-o~`|zO;8)+WT1AOG@&GVk?x7-gw&E
zp7wU6y<5`WuC&*3yj(rnT6bE%<M=CE!OaKV*kA@c_3K0*E4#?n$6^yPyXW4#1M|p2
zY<uao>!Hk!4w^abE4YxEjPcn4^7@h;^>L`Pqr-!Zsh;w9_i9@{BMlnxXe$bR8Y=JT
z?%z}EOt<f>U9r?NUNt9pAOnV?t;uN199<TxPDXliZyKxsv=?nHNdF8AK)v=2EHOJM
zB94T1P6&*a@X_UQ<2tCzYJt}xP^Ln&8>z<kK#D{@?-MT4Bds}l<g2{!q7@JVRFP#>
z*kWwyzT1I6dHKxQjcIrxDKN<6p@HTUPkm=7$Moj4hz^v}U$fJT4v}7bh;&b{bkheC
zg-RVTJjSM`#Hi@H@DXR$<oz6~I;he~szmB!@@pxNLzT*)w<>?4Q~nsIe9@UTML)+%
z)?0931)2DZyw*9@Z_uK@1<@jpOG8>c7Bv`p3w!7QL{9yjW`Bxg5nDeJ&ml+onUYP7
z@{^T+8LP|`TSurmGiIe+#u!^g$R~QXQ9ZErOW89?_g`coa=P4U{W5v^tW5m$<mGd+
z!gDjjJ`>Z_f&s#iq^xebCmT%x1A|~as2?;NInbdm1d{KP(~&MIc_0nPz0P$>Mt=xB
zSH(F885`8R7XbKFU``_$PmV+cV9ad`|08qY9lJUC73oIfGHIznsueU*Glt%$z2ME*
zAJR>XlZ}y|6}dx2y+)MU!x8=8jC7$^jKcT)<^@H*$mc~1UiX{6yz2V6--w5&_{|6f
z6@uE5GiBynx(s3SFfPQRM<T|@?WWkcoQbh%x94;Z)g$p7zv=zL7wJKUqcOAVmCfOV
z(e5+a{l@q_R&*UShwA!mT66%C&GGq&tN#mYUAhAQWq8$hYD<V{&@?F>BOkhrw&&|s
zWBDEn<V=oTu_@nYG<6Setd8ysU0}S4fF5be3sk-w`jP22r+hJ%d9}%FE1R{+%@PO&
zV~utGWYTAJ`kMBS@|Sn|OFMm$eaTSVw{YJAWcO(gHIG%E->$8Wc7}gno%dnr(aQZk
z?ZIX(xF1n|t-8JYmwuz&7@zMq-V#vvz6D%|-aG_i>Z4sQ7ox|RId$4o7!Lyt5$MLf
z&jJVC*o|R0&yhOp1aQX+4M~Z2vHnur@c9X#!_<-hHd{af>bT{}@|~&uGfdQaq-}2H
zPfN5VG6Ic#df!Q&pz*FX1tqb(emiJ%>1Ki791neIMuBcpZ<<jA7jc(@k7jt_r&|Ko
z1Gfw=w5J&raG^=f@WO=}H3J(RRHbIrz}4Z-gj)l57TlR|=fIr>cP_-p9Nic{FHy#2
zq*>)j{0u$p6Vw!beIy~W4Ct77iI1_}W6N8$lPLlQy4gRGPOdcvV))cCfFUsmgrjgd
znuBD3trUk2*NsmUDHA<!W{m%X>i(ONLxj>R;yI*HdPK4*q4aCzUq)y$h0^V+&J3Y6
zmodgxYmT@MbQdC&mPZO?P9C<r%8(ZgY$8iu=tevCWBl54%~-d?7c>oy$3Sws(x)@!
zjewX{o|4KOBDEZb8c>|W3B_&tD|y7}FeQ&xZbslB@@Uh?B9GSZ{6CjR<tfeMoFZr*
z5EdExvLcWCW))@6{D1k)i<CIpW-jUi$PiJRL}naDnNcM&<4MGu_x6$*zd}^dT=ESv
zV_0vI5v<()KOi#R^l86s*3RuMGODsg#xO|v)!1N%q&0JHhu{#QG1!O@C1a@)8gF4J
zFq}y%;gUK;+DoU_<3NZRj?j1l@gg*a&Te$%#kHC8;vA6|$DmNAyr_blm|B1_P1lwe
z7eP);^&pO}Eia~)AzXs6Eia~e5r({&YRikMH3;hn+wx-SEQBF1rrPpi>Rcr+s^%q5
z6R|K}$qTg~l`$ULfk*au_y&0qXZCL+FWO%_l)QKZIYeIkMm&d<7dJ^ZB`<!W{L2VU
zro1>$)tMnLyo`aos1VnY7bhb04f5hZdC-NH((*vk9Ti1Mj9+v}jsx_QEd=q9^1@Qp
z+w#KE-yMm~lO=OXUinVhsu`Ym0lBfKp-0wc?$PMxh>~x!M{`oAP50x)b4a>>wTbx^
z-FGYhG9r~p_qQZIbBWl_7}?SwnAS=Jd+*Vtuz9gJHk2wlc4!=Q4z)vbnQFSgnjxM;
zqI0rjQ|KJ0{0E>jP}P~iM*Gmc8R&e7VAc-Jo6KQihi0Q>wK?swOA;?I?5u*+_>1Kl
z=yAPvogO)>-KG69Yds+gr;PJIC_TTB{GDb_W6SKu-sh7zoUArp)|M;);bP;U#%_dq
z2nD%WZ|dr=H@%yqmtw<kwA&Z+;gl#lB@jCcis$?D&kP#f-I_h$MOx<Sm7j-B(0Ts!
ziFNVOBE&4+*ySK1+HGonjkF^FN8#l-SnEC6*z+%@q3;A^gK|E=tXA9UTQL`)Ca!(e
z*{|ZxcINsO8k~nh=19GEN(sun{BJ5cEQB>c;tZ7g6jVr$U%$EVF(h(IJ4H8*W$>Rl
zBy^%untf23g9~%Iho$pVeXgweB7~F1_V8}3=H%=otuHv^&-9g)Z<9r|ZoGjN%CPR!
zrT-$W7<(;qD{n5DUks+u`=0C3jSsEUM+%v?J2XhGhtgz0lpj-(nrsN~cQNri4S0Pq
z9h-2$_B>LevS2~(nKe1{aflNKj7{N>QZP#S8B^^VL^YOW12ub~E>#(uDyQU_ZohU;
zAjenP<kKcMK|_z4Y{qCIReYtdO^k(_@~g4Q(6nz<b@_(s(hb2_AisME+mCJwofCkj
zUv0D)?ZL{8p{c&gA;zX^)Axl>J7<8Obq3oj*M};x-td)nR2$9I_N&V~s!Ka6JE+M=
zdXk|vmFu;KTBzgy#h3S1D7U(@Wx-?B#ult8erI%CbZLq{JZFdYbvtEcdE8&Ike<*0
z(os0WZ%!=oR|bm0J9YECJlzcBSx3G?ZAH5$-o3Rkb39b&u{FhYC>}JTwtHuB1H#bJ
z0>&%o$MSXMIMUyz8@CmgShpi<Y^GbzG;s*2*TPO<t2F|Zga2?G9XbkGak41`p~;$x
z?33$vhH|QnE5VB#4Hc>L`qXh>qtf@F?jg^H@^#6=78uiTs!L8SN*1;vARGa^182PL
z0NgmTOco|!o}*(=2a-HK?}*vj$MM~|c4B<Dc0ul<A0i12wqU=dnJN0F4<lV}eLyp_
zH1F1CO18_KY-xT^?a!9MmH{LPv|&PVxmJ1bPZmT$qb+D`w2EK0@oov-7Bpr-9hrlz
zU~gV|XZgA|e=)NIBLEjLwgzLlg;;+i3m0E6C#Jg5H}pO1)P{zx;$jN}HCZ?f$Y2;3
z09)f|fL>;Al_lTo-a$G)ya5Z*zRaCYBmc>8%!td_9|@fb{T%aRXt*4lCJVhnuz|_K
z59R_6XSZS^YEI*isz~dUJq7r!VpR#+Rja`<$V_oF3_uHd$-+~Jlyn0Lp4tAeWZ`cz
zTk2Xb;P<XSdHh1;Nv}VW$A6L;R{T+x0^rZAgZ$PaFeD5A#1>+c@{)y*OI!9vyCZKi
z;W<K&1(0um<g@o`f@zp+dBG8;(+XjOvmVfs#}5LMlCH<D&x4##7H+ssXqYVAE!Ej`
z7_y#%aGHLiA6D4)9Shzp+`rxB+8xwJH-pp|5hyViB^-EJ|88x_G;lRrxe~4H)(RxJ
z73)q`u+pg@S$IaOZB^5A$liN?aP(8bXP8f<AR5L#BO2aI92|u9!+H)(VQ0Y-w{VM~
zn8s`-!>~6{_6V^-C1<%^L5#(+U<^B}$-)ApV_B5%@TrcOhkLGw%ac*8V>}{%MY8a8
zWHp*4BX%)gBmaO%@p-c{hH=55H@nc;u|W-Ik_eZ!gD!*q41cn431BsI?}NX(Jnn#V
zKY~W?nUW!f43K%z>oM%GB^62Y*VoB|?j_Q{X72tUxLxV_&3C?UMurZd>$RtEMF#26
zJBu5^ms-P4hzP*Fj<RLFAfOeDJPxq$)=q3C;Ip-pHfWKB$c8MVn}Dd+aIY%V$wD2o
zwUT$y&AI=^&i`($dAobIHti)yDafvqTC~UscFDM|J+-TvQdx(L;iz=^R^;Hn-qu6`
z6U#XRBFB>~Jp3Ah$Wfw2;YBZvJ_D9Tzh$&J#>1XA$KH=n&^-NEINgUk{O3z<9{T}G
zsQpy51p)_+tBXCWM!7WMkL2s9IbgJfLKIwYI9V`7=td}=FZpJmvMv1d<k*Pst1K#2
zN&2lp<Kp5H{;Np788qPpDgi2FDkh_S$v2XPcV6vwDL|q(1G9|&+nOvq0f~;_)167h
zcd75Pmd4%M#Vz_OQU<>|k~^-KcO+V{u#^4;rJFL+k=x0`UNL^c1>nJ01m!x=AsvY+
zk^?>V@j88z6?qqvN(cK8+&Oby;w$VV31o@O0kv*Mg++8@W<k)H2f<MWW3LIB_}Jsq
z*ubfp!nzoCPz!)xax-_G`a-b5gXysFl%Jy4+N$!1m>R(?m`3Zwmd_RHPsI@WQtLt<
zAiJ@R4D|?M6`LiGO7z$ryI2kFtXi%6j&Ql|C*ST}%_Y9DvUcL6e6Vl4JPrnK!pQ4q
zx2dR@njdWVd)24^7wUsf({Otc8SpQ=06TS@hTD%xhm|}xUNi50AE0VasZEKPNp!3i
z564m?!i3UD7ydh{Lx%qA=&LCTY?cZA73)Tpolz8wE%KnX`p)?k{@8iRVC_TP>#$?Z
zhe)45q<L5n8|+vv1l+rI!);uUht1xCpnFTOa#Q#tv)W}WA`l!o{T10RgH4rCE)Bnh
z99i(cQ%LxkP%2m)1b$(zMYne#Ptf$0K{`&PH+DxHPU7snWb@4R!GZbrV+cC=2Op5X
zm$aLum10C|rMDHA`L$Aiu^0b?#Wi3MYyo3})ML*O5bMW#lF8kE$gla^$UY^zUIYnU
z-9JbFS(A{)!K0gIJ0c<FOwnCCF;X|9ruS$2w302e{aOh|(50I=8bwL#LZKayg&#r|
zmb?LZ`1WjV`kS-08LwfWy^eWs6Wq<Hq{F(e2UtHR$I9408p{elDc@=IEb14<M*giB
zZdwWPC=onL1dkHnfv%aAmL6)P1Y>_9D+OUcxp26+Mw@j4d^mVu=NnB%&;7o=JwBt=
zXfL(BFIiW91`22ww`Po;3ovR%_Za(2KlD|;{_}t-oQitOclxxaUbj9S#__i`x%58N
zY8{XABwRJ@O_sa>5#u+W=|V!av5R(w$kvEZ;$ez0#q+4i_|ke3wREq~;BPE!dXTfc
zGjR&~cDB;5^~kC?B01heC$|doaD3_J9qf|wPOBgCqJx;pS_M$_wg~<F+5KicgMQT2
zI72GS@dpxmE=sfk3VT0>+EeT8974TYco@Znow-cO(2vx3I23%d*|-hgQ3r=_*f+p;
zLK?oT`Fzg7Ib4rDPA<^F;$Vb%L+MRGQXUOo>8|^goTNQy+>n7fe_%#0ad<c*WAdl=
z$hZPb4^tcVu?!ApzO}hD$~z|3DC9<t|H-j(HK>O+BkZAQJnSWYD~1SumKW|JaI<d1
z>7R{9!po8MT!hjY<E~J~9numdjCalxP=5vM^%-l?mZBU6kM&vs##E_gx97tsI|fxB
zIEMV%Xv=SW=r4WOSGoD;r>bFunlOkqTN_bHY7kY|W7Mps;H@@#w7bRwibRm0*pq~j
zs5W+351<HgYD;dHQRd{A{zJMw(5~b_<NW!xl4DL<azO7$=_kU^_M{B<2_I%p$jK>K
zjGJm`szLK39H%<tlheP9TWSEg)&%eYatjM0VxTJUJJ6?5ycz2=nSXWjZ$#Tysm?Rz
zi~X-`8bE!PnLY^X-wN6S<2((E3F}HMJayPhl+X^iEC?Im3cq<?Q8nhhX+9io25W!4
zf&(D-w-WR&r#kc36o2Q$?ipHv7%WcIe0JdU=QG{L?VQ8Pp(U09UTA1AnUIRQ-&I!y
zJi6JZRi=5=^cqAFrUmXVVDdOA*Y^f)%Jd1{q697_s`gYBl#wA3j3G=Q7v!FR9C~cE
z(8t&ZH3d_Lh}#b9i^1INFj}?xdSr&RMfo0U4&rP+Gh}wP9{B_WrhY7fOpD^M)g@aL
zv`}dQFe9IRUFNC=3OWo)OgaU1ariMKZR&^F2zvhX*DxEwrDCWep{`Hggh*^K3=wn^
z72rQTvYI7b5WSHOddfRR_{w}}nFPfaZ9m)v|AC^nf>|<TE=)+K1En;;sTR&SSPP{Y
zExgS$GgGk6Y{+QhzPZcVr~pVwceK<!2=h)ChJ)&FyZ=P3K-a-MTgj4E5d)O@pj4y|
zm9Z;%4smNgE&6MO5kH7w)vb2-sh+){9UTRliDqC=q3JFy1q7-~e~)TZm;N&U>s3}G
z(k0D_+A5$}&k^l!?C+Pb!4C*!LbUt)_PA8@E&E#<N*r;>{(eAuKuxvhess|O)|sVu
ze_siFzioe4X0))AhofKL-~UtqWcK&x1AFy%YCp__{V?kzR>##}w3vfWi+<S;Tr-ok
z$ZC@blyO>g2@*2)jXr}kk%InWU5h?}#5Qj+GQ#oDS;hHCZ85D^S+S$2MHeC?RNN0R
zY}%AT5%LBNk5$M_u|ZpqfP?-#E0^KO{5*yVwCJ8(1iAj-36E9MAEDazRdZ3;I0wtr
z4c3)TBjY_<v>lmX{juaXNas;Y_u%w;3CAlQ?108bl;9M}`iStD1vsXes~fOZlA}oo
z_L>45C*l}JjwN|i=|LDmPL3r@;6m)mF(r>Bc}(er>xHYs)#28_t%1v9Ngh+qf;-DT
zmYh>LzeKz1MsQZ!qQ?LtbP(679Q<2JpY`kIf~#&UT85w&-H)Vzd0VmGh6OtboKql9
z9y%7Gd~gz+0t_lR!y!lD6oEo;M&ya(86ZyaVd9iv_D0%hHrD3l)k8R^vHdo01t<sS
zERY3`molWy>*pFDV=1>0rw@8;kqglr{04$>3$KE!3=5eba6iprlFd7cS%xe^w<1Qa
zuO2&tF-zhSvj+cZNQ0Pr$+T_bi=>X)^NY+0BWU5X<V-+T*^G^kJFkbY(Y>wmt)K6&
z+@eK)grIJo3;VLyaMIJ)8v2~jO^dDrN;+!LjR^(DWg}t}-Nv~HoYo=yD4c1Xt}+W#
z{*L)$gXV4|jA9%GNP@<9t-8NU!Ym{RQ_f{L&6Jn39GP+^Jl0Zz)0-(fn4jZ_OnE9Y
zkty#(<-(K$L?7wRkCzHg|8Mc*VGb6HmH~7v`V+9j{}cQ;()9}Ho8rgg_q{CqIA$x{
zZ|28`4&cW};=rwKQ3gN$#pXxElbiC)3Hid0{{e$4e*6-?41W9wLEY3Gc8okDov%f)
zyC@atMt|e7eBnlH9G!-9$=p|=ya%Af)xh5uLYMxT@GrLGXTkqDW_!lZfj<dxP5)f@
ztFTC>e;)HglccDwBdoF9EtoJEY*4|+r8ax#DwaFZP9-BE^LOmB%T(}U0V7)cm<n>f
zVO1Q`$UGQ}G6o@S8N5zlix$UKu*|NRltb#}c2y)cf<x`#78QKYuDMGEPqTv-g4p1#
zOs_XSv9`Q{R?RzQCQ=IZ9-O8!W)};KiaiZ6N{QhLR+%Mp=OnUUTU~%$+Fi}C(oJlj
z!9R{){@%NS@QdBh^|(IBXeWGM_mhpfIiVo2k_Nu1iUvS=N({w6-Rz$j4L5!I)z}!>
zSAEk!U>n6b1Xsp9=#J$cE|PP2fR?nq*UQ)sgEgf8%yD_49G>j*V6+UXd%nMNN`81}
zHO@w%cQ<YC(_JX=`AxqY@&PuGXZri(hYNx@#_blw)qY2|eeQ~*fPBXKg7CnEqiH*i
z$GdPm-UR4YkX7C7sKASD5nrAhDiDzGojD~R8<^M&LzfIz@+#7lQ#s{}PytTU{gv_X
z$C4Rl!S;S7j%TrZ78`j5>cl=V4iBqiQ<GS5^ywbT`hAfm93VH(g<<4Tq4WHe7v_a`
z!0c-NF{UrSa$J7+9kc{HLVq6zNq2sDL$I<V+&#H=UC?L;DFpIBY12eAXCRg<g8W4Q
zz7Cjji%^~LF$Vn^*_Wp+{uL5{XU;n43kTlkTlu%%_rs0^=qMazbu5<13YS74W~Oh&
zT#^|+5~CwCyl!RhZ~_xvDm}ZuGR`Kjt2^>-$g*<mTE2?|+@SHV?lW}rMr<qZ2_1tK
zo0a?vWYOBtMTjh5WIiK5RFM~ol}t-fBv~E0S~qbEdrt@_kDplUB|ZGyWTPu+e8`wx
zh{2i8!$uEQcQ{G1FJTM)(z#d;xt4ZsNyj}WaiP|9Tj6`uu28C$%)tS_+FzEL*w`!z
zrS&)}k!i98Sk-REDTFlxRu4FpJeEWC2}_17?)1!MM!9(dAnpCvwyGj_6V@qhRU>Sl
zZuT{*JQ+DN_S4k<l-QexhFRyRy48Ao2&!+)UXQ~ZqnEvf=_|T_?=2p^wps7%%WG-e
z<(^X1l2O0u8<CwpqIY_cIb}pCr9d6QMg8WKA~P_ebUh+*zUCWY_=<o|ul;4%;6usv
z{!8vYA9Zk?hfzaSr@a~QBz_7>m(d5<mvDq;f7*5?XBB*!37_;2wA#%+b4U;up3Ef_
z-#id3G4359Q=B_lQ&b;cm52Cw6S2jPJ%*rcF^Da4Fm^BXMvU=7zqy2a4C+QQwj6@6
z73Btdp5M^1!yd;DdlT-&g?9#xVdb4jlmpZjyN2!r<%OKyns*Qg^KQ0}^DDretnoDU
zjEZ!j8W>7s;A_Kg-VtZZavq|`aF0aFlsRB~c#MgKX`GAGayhe$W7~m8B<gS^1&mrB
zd(GR+h?LY9G+u>lyiGTkaxbN_zjjW493L7Hz6@gY51nUDg6*lcgojp<1a@A;+A<hh
zTEQBcw!?be6tcwb9LQT>q>53HCP_0bb3l^AWgvOEfkB~0l^oP~Nh0i>ULMw-rN{0j
z9PA>jMBJ&9M0z|dB;7UdggyS^v-<E{)`$=nEqW%`wrvp><_}xUWr$h9e(kQe;Z1}P
zm1%GE-%VdN9?d&A?}NP7ns+#_E|s9#Uu%`UO}BMQ7gJ28SdSo=kO#I0<dXFI&Z)1*
zuJ3A9p9Ga5Uu)zvVC=Tul@!^+vt}HkKH1O9LosWFD#bMrz+_Zwq*Us=Tct2chGD{u
z2<Q*LknyIr0~6OE?x6eSU4WMa2wmTLJ1e($+Y4A56r6s^!u{v+lvm+@?>{rC#0IQk
z(tIZ2ESG{vC>D|uW*4(Q_O^69{rsU)r<ozi!UxXbv1EiXcA``tRpo__Z4pNCXI-PB
zrMueXR;)y~sumc{pU?vxh54A{nL0+>xZzBJmNDCJjO#PsYg?@4p971v0$AAG2<0A>
zic}2M7JnbWn0bNP{02yj<o1OVQMM0KrM`F$b)Yvz5X^3rG#r3`V9QsA>%h=&W`w;6
zw`GJq2rthF7a;s-MmP`QUuA@I5MG=S#)3%32|1DN0oueBNp`e^(Yz}$%??K<4)@B5
zv0WZvPvZNM$b2q@3lb;v3g^i#R62i7qJOXSK8d|wu`#E-JMlp}jD_t!*!WndJ&wtZ
z`Y7lh**8R6{0uoOmfHXYgE~<@-Z*Gab~TpAR|0*QA$a+JCI7dLE5h2<HQN|BVzx2y
z=+<$by4G>WxLU^@i@)QZXdPD!_xOs|ao>HQb=(Qpvp)yp-$b##Z&|_Ws>`>b7P1s-
zIa)*va$Jb|#toLxAuBb;sp`tt`J_gl0&^8>PgOl}1RMW05Kbh7=h;=p?FtA4v6Kdg
zq5$hb3&d4mrLu8Qq#gL|s#dU6b$O>x79UcSF>I7DUU+C2Gb$wYyPvf8=VOB&$I`;O
z;!)L~O5R0Q?Lr<$e#qFBE$KTv?B#lqAFC#b{NM<-X1pcx!<LF<SnIW3Q6lT&5~U>M
zY0A%LtT|gnen^vS)ij-EAU`geDDs0b{2{Rmj`i%r;%8HkE{x*O8l$Qeq1hH;sze{2
zZW+0mD$&=eh6y%*j#$Z*{|D}8!zkEj^DbIVDZMCiBL26kIS&-F4KEuaLlAAvV)e4C
zOhDA5K-Q#GB*D<4U1->PZi|zXuxL??FzjQo5?9Eh%wuRcm@J$g05zma5=4tWj~udK
zStJrRXpZNR|MD|9f2;E$<1I^nlX{-f7XA^aC;jyZ+N)bVn)QcAVBX2>xDNrKofdlE
zDNv6Brp)tDqp?FOw#*%0I*~#-C>FfGDoKAwlBoZ3U}8ruL!<!fWT*U4`RkbkIq2%%
zaIpC|vQl_Zht1vD&^U#g-UU|nlnE$F;Z`}~cUv<_O*J`NFH0_&kSv$-3$ozhTq~&}
zSXQn2KT;9GK9XayiXdyM9A~KrQeUu0Jn$-J<+Q%woL?E6aaZQt50J~)01FZ<i<F$P
zUi%%FJ+Q})6?WkIn2P19X_X{|kJgP*Sa9&vvPN0O2??F`<BC3BSDkJ@(xkQ~daWna
z_@#akm}4b3k`R;TTK|4YJoBu#l}9Xz`iTyUUFk_!>|sc!f<?W81AB!g!3<A^e-$~A
zH`#j?g=J)_rn;Zaa)nPuo|$%$0#&4p!4s%j@-{DVkV_p=&=};3P4XrS_vn~%*OC(?
zJ!8LN1*WRxF0ILz2it34F8rjzafXS1S^2hV95@fJTP0IO=xkZz;mSDp&56SUVzx?8
z+et0}YG7XIlQU0ai*xo!TUxAHvU1ME0OZ-|yrC+eyZa#sQw9HOOzy6X_8k4Oow(5~
ziCVq1=W!MfgH2KOOJ#W3>z0%~vm=kmaIO^tR4ro9Evl-k^>#`iTe~A?TkBt!aUoo;
z#)UNj8(tU?lDrzp*b{ldp5LW@m{64vEIDdzy`7THu2J|L-343g_0<`+)+zfg5J#$=
zc3`WUBucefEv>4~L@%Vri^5O%wcXOB#ME~1OuV%!;kK4Y#H4mB_gj^J^)=#|QT`mK
z{92@>75uMj|E}!vgPrpA->Uq%+2uD%1mLg!R^_$q@=KiZxnEaa?SDYX*b8xMLnp;I
zyVDge!TLW!DUW@Y*^reY#%w<53)Jj<p|{MXlB+Z9#bKc8^Eh{TZp7J>J&jc9m^p<D
z$z)-)LJ>6;ThGo#uwSf)B&=IqCQUE53$_YZyK%}s4n<TuQm`Oha3%`c*^%!ksoJUZ
zETkQ<Uc>~H!gt%I6dvKxz}FN^)@k*}0*)-4NnZ!&%`n(vR;(Db`aQrYjky+u_(51<
zP9mf+*NrOOx*2Vzu($4Cmjd6K%#_}Q{&hx&%y0-Dddnu17Jaf;+ac`fel69L9U1Ln
zFk#y&@g20D>f|TVNQ9jp07=`VoI}z?yByXldF6mn|0Q(%1Nv+U3TF0MA|KNCfLwF3
za;1BAKAN(#0}L<nCDx;zjQO&cz16}UkAWCk>9b-L3%$p;0;Zyv6AFLX0f(Jl4#R-B
zP;80fX57xY4JOUpLed(Rpx^3NyYb((0_`MM9nP%SxR?c3JaZk-9LF<HdDLkK{j+fj
zGHW)>VCHJkk5LtmDnE;3#aNZ^gT9sH@`;5OOiC76$d24sz|=7JEo7nHe*0ux42fM`
zJS!Nx5mvpyVjUNnf|%f^;B*5oPVjnD>uxNtmQO3bR$J~b{!uk9#V8988rr~yyV-B-
zZ|dnwK(5x7$F-->1pIS2X9Afrv<hlmO$+HOY}~QGk_T9|hJpC+)MntR4Q_2=X1m!Y
zOXw_9^j~MQ%FYU&rG`aAWwmjIg7)53qz<hmYv!PmQ(#EK9)jYz9*b0`nV6WZP~YLP
z1Y4Yo&M-7o*yvkBtqwWc>7<ndr`=vLB&T(lC@uEbll=$3@dxhIwMLG_f46mu${?9{
zz5;I2N)*HB3tu91&Q`G)e2+cSWi)6}zQ8v&4_@CI&Y?JU1b2)b?CM{q)n5RwZw)f2
zRkZ^dcKLA94rILKtkZ<?gT*sd1*R{D{hlm5%Zr-^Rr!?&uxn<b7TCsfn84D_x6*at
zkNQ-X@2oCQCM>A9y7>$t^sUkGpGsd0M+v+`)rztuESuV8!wV4sW7o>Wmr&)+F@<Nl
zUA`nP&KYgmlD~kpW4c@2Yp7jktw1GM6u{;l$HHhCI)qr;W52H2_{6CN#Ve8FV>ALA
zdh13MN?f4^eO%%?gW!1xe8n+ZgD;&Zk<b)n%<&i|ZG@B>qPwy3N50JAm;}l;-vyyC
z!Ls90uuX3UOtYNgw+nI&3^EQVaWSB}CL7xwRwINME*Kwd>g&dWv}Nq!6Pf)L5)dE2
zdi54Ka$$kRlQkvm*$bs#Orb$cSw6)I3l%bolN-LTvXJBS*fTD$ibw$KvJLD~XOE2X
z$l=j9kkUPh`sQkxGsD<0cJhh76n$CjEc?O667RpMT{sU4B~DJaWod|T#_i8+5=hGe
zJrq`4)-ca<yKebTg0N9vR(pt;oP0)yvQ<Pm4((N7jAZf+WltL3g4lMV(`)?2RSXPp
zKssroAn{xA3VC`p4XJqg2RM0}cfAAt6in5KU0TOlQrMCz5S5#)p+JVM+u5O@Pqa=_
zGk=^VaCXE#!JhiOqj6wYJPR|k--yu2WB!8~=Cj>*$x#94-=)h?Fi{S?toJbu%03sW
zm+CTyuVTK2xjd|egq<mjj$xS^#W#V7N=l~&vGx1zl(;?uhskMiP0=Ye!UNMo81rGH
zKU-Ye-A1Xc_}%7n9tT{I`v^Ak$>QS5oS{{3PaJ`+?=>GrcFe<*g#kPl(^mHwP~}fq
z_Hg$eS2J)~*;=)f-55{V_uPT)oq*Xt7(4xG92DxYv18!`F(FkDw+hz5n|a=VIRSGK
z?5*H|G6t&wcwpB8AqJ0!o>@K<&)H&guN}h{i<;V;#k#vE*@Zh*1*k@L^VH7XY@ab<
zgs*La+S&6N=O68Bo#3fcyMC<`j&UJ)EdL$%1pXD%cYFo@efI(U!ycc{ICt>uYGcAs
zpSJvbye>W2HQ7i^hM6ws!gonrG?0(E5N5p-a^TMsX2AgkEK|wEM*v)0F?$l$5j=}Y
zp^6b+U&OhpR&1km^WJ5E9MaQRLW&wAZpWtOZ&!e1cxx+Ixl60h13U4)nKyvT8F2N0
zv_|^C0EjU&;VGhL7CatVR?O=)={SV2ckR~sgj~MW9<)eAh62@dN8q1BCMJLoha^+A
zaoOO+R*1CJdXr6Y>gryq_Vdc)P7Lb9_9Od6ZE&)B29Fk~kcurx1P8AuQjH(?gn)*G
zVwaO8vyT#&qh0Lhs;+1MtGx?p!f6x%2Pet#EpSS8eZqwXWcQYupG~qnw4>m%5lxd$
zvI>^?_w7jc5QQuD$8h3q-EcQ*ZWN_JyQhioci+>Tw@Ittfjnc+r)Ch{F0%OBvx4kk
zC3d1zs()mEBJq}r@`GlX_XVNvqVLK(aWDU2OgPR|y08MV0pnFbIudgsM<VX*HRIHR
z^Hn~$Ibhx;d18y9ejo!L+o7e8EkCseixrr6Q6mh-o-O8#HQD%&^%Qr1V$ovG2Q1;m
z`v-L|3jb*JwTMJWE&iiC)3R&uwJw%OUI%AQ);v^$eSIFdly~AiR2v#9uU?-ZERaC$
z)NsIpreIk^a5+wg;(jd<(c7XDg(@VO5CtHzF`%7!d8m|pR<c3-r(~Bi>BB8yao<W#
zY)tnsC>j%Vo@C*|(@8K``ql46{AA<btEqKS6Mu6D&3*3T)MP!-0-<aCmP^5a`71^t
zMW*N>KogphFL{2ElX*TeH&V?+?p`B4)!(RtR7U|J)o)Noip0_1fWeW%4A!Zr3Vxvr
z^cB^46{#3dp&-z<n92Ng-(m09;Hmi4)Tpgtz(EdrP(%>vY(`UUi-`y~_!B3AD%g*O
z2_fsSmd4ltah*!y379?(Mp9n76mC;Abu>rZBL+KEwuA~{T<y@&It3LbsERr;8*7T|
z&{U+`Z9G`q0N-RBCl@J(5E#;2afZm)UR?1hn#ksgB2<#a6<?r1-TW_b#ZOPQxgz=@
zN4G<s(4A@W<mLWvlIIB2iTkPbZ}+A~V~QI0ks8K!n-&<rV0!ehtXWSKjP8`7rN{13
zrg5p%e5B%*=+h_yURH}#t>H$nK!)}7a?=JrT093WY0=SG_hQi1p%m<>IX+-VO$UYq
z(JR3ocoP0@0F6NtLLLl?HO0G7lIuw<S8a1WGxt*DVQ?Apa1@hsWfTke1?(?I@yBGc
zyl%q63k)4XmSAjro-9ALhLAMctH<4}JWCEp1FQk1_1KIGTSq?wr87*x+wLG3;AKp~
zTC{>y$4<ZDZBai5UHDfZoiYY*t=mHAq_A#0&4Eq!A+j(Mmg^g0JVY$#5`3e~n&VWD
zE63ZYJK%i=RIZzU7Gcz;UOYriv{rr(UDGNzPq6e+?>M8sSU>DQv>{8|*&+tSJj6J|
z$`T=kXCA&@s-@&vvT$XYa4fE@ECDb<)9xx#NhDgL6nd?*|I91J9fG9YTLu*FXfcUE
zn`8RBlpm^0wAfO9Xfw)UpSH!)x5&9h5d<ktuguEq@W_H9Voccs-IEUN>R}6x{P!VH
z35WCqvFE_mqJ3c?uGh}U!~2Oee7)<l0>}#62y%YvetFs+`&iV4=bBUYuMG%dMv3AO
zLF&<se#WJ=e~o;u8RtNiJ*$J@u@m_t{G_?IWDOds++b|c?rMV%4Q!adpSQ_*;+xUH
zu}%Y|iOCA3{weMV28kPXj>Zf&(hj{Z1mx=22HImA{Au;uuu@9*4hE7VnJb<bA?ZO*
z>*~Lgk<>WtJ>OuOEkO=<z*sCf??$Pt=_k2{QQO%pY09595T<Qth+Sm8iuA;ZJ&^mU
z{rNONU>D4NYVz0&%df<KWDJsvoII;pC+ElIOy0(N8Y%7>op_14G5K)&#JZOmRxzfw
zOGG<Ttn$U6h&{tx1==2Th6!cOFls0y3tt}t5!xE^V1{wP5!i&ot=2_=U>w?O6t$Z)
zz+fclbzGZ|jZb3qlId{J2HMIv#@Ae|>rf031&k&wdJ}uQ7H_k_hIDtph+`t;m~SLH
z-)BC^FAOy3T}{5$oJ!DPvYe6)O^Z4v^Our@Bwl)#QY2Ox@6UO#7xo_3#<ql?XG?gN
zr-WaDI)YHc;!+pp0rGXjdC0}3rC`V=$OT+AD)VUUj^tkVXH-zX4q~NF2Cj`O!yTwg
zl~ydN3bF+jJOc%hOD?xz-5F;Irr`w>&NL#(*&Khpumd7TH8YN~+><OIppSn^7FO^P
zooA(xGo6`8HB}^5M#x5{#&ao%W53{;Az)yPgT%Q<IuPDWD43hSUQmFO1b`BIGC2Wl
z)U7F=#k^Ymc`~(Nq2{y(ppS<-t;gngb=*3U>e{N&|A=d=&ZEnBh)j2DRO$feB}A-4
z2JpkhI_jNV|GpM|5fRYN!D<Bk>xFfe3JQBx5%9^vuW&dgdv?(f>#p5p50+1?oG2>f
zV8Jb>nbORG)u(pxRQ>5{A4Rp5ZK30^gV<}ZSPw-oP7X(PX?@fPi=Zb07}}AKaq9Z4
z5I$(mDzGM_0J$$Ze-J#i7~${2UN&I#SjQp7p>b<Y1qK=}PSx)x9UuWSX?+XqM}jeL
ziq-+#9ugY2d4<*o68guo5%X+u4QiVmIr}TEemY{z@j1R1sH6mA#~%svqG0ULGL^l^
zTR(o|Ge4dWnT9EUjz4yD(jQxZZ2~o9DG$m2{9)U`Z`_mv)itehRxl$oV92W_$RZFh
zvs8UDd`9F;Tn|PI;l60ghj+=UEBA&U#N7YJV}PZyON(+t+h?9t9EiM>leigxVt;R8
zlDo=SI!2OMK*sZ$!($dExq1v8->YkMW3Px_&~A<~Atw?3l*PR+v>LkG6yptl%<DEI
z!_f%l#|1ydBfSMLl92NUx|6=jo(20VdqT6Yy+u*4*S_foDXx~AN^=(4o%qUOe20M1
zhHUa1t63X1(F)+;%Gb2Xweg8Df4s*iG3Mo9et{GpihsUJ>?<$0U(VarZdErPi)Js!
zbezV|!SXNhYj72=Ra3r#9{6rg;y)OLBpRgPG%fm5wC&(AD~*SC*AgW7B460JXvF0U
z;-W<tASI2Dpz@nK8<oeI)*FjI5R1vR@8jX-t{&q=zi~s3I<-K)rvZ{r6gd(&fQQlK
zX=aFeV|<Q-N}2T#7ER#x`j@2TJBw$cMzX}=L~EI#MYdoxe<=pzbvdxH9y@=geID>I
zCL^jC%sM;rL$L7OoDR*0MO66B>vDpzn~NZc9(V+h$qo#LU$yb)V%`a|Ucn24NL+$M
zM5}aTt@RwDu>m$zTaN88Joy$q9wTUWWS>W?_hRCm9ob)`)t>?1s{W|O7rCvt$n7)k
zDTa6lu+y+%2k1Gy5CPrjz=PJPK+k1ZUTsq=3BU0KW8iRiRmj6leQc`7^fK!fY<!YP
zzePKw07Zu$!&@SlE*qpFMWHrd1wvpr?{MFqI6i;&hknq!eHF+K2Ro{O@C6Xs1(+U$
zBNqgt#SnZhUK#W~kNUX+xs6N?cOIALzBK@tp}B*Vdo=`;>v^J!$T|7SoyNP0FQPe@
zZ#5QcE}!g*`c`5laLKXA3Tb^$9M{DC=)5_`l!`Y0!n2@1W9VQ@aeX!3;4|Lx8J`;;
z`;C9$Vt+LR3^~~ksXL8juBLAeeRJu%n!b7T&86=)`sVq;0mO%a+ZZ68ek`UK38LhL
zu3~1Vd4l&p);yZa3tgPqT+V-Ub7-LecWg2cBJKa{2%%n2NYAX7J^O!JFKY9K&d#ij
z%=5oj8|tVFot9Y#x$@i8;oBSM&<dSsa~yg65an0|j2SxKF2W)6^+lK)9UD5<&drhV
zHMyA;aEC_OSvhzPmX-N1216t4d>nBH<YOieG96`S;_%GM#4KK9Il|5&hn$(C4e51A
zA8w~}+^4EwVNfnK#7-QNO7t!4qIq^`pq)ZFLb*g)Wc@>oFO<%|QaU<TQ`Y7cH4<Oe
z@w8QyAe&3>c3XGdijq{isyte>6{Atdmk}YI+L;AEoS9s_46(5>*NC%5Qt&X^3>cG8
z{B<CcE)Uh)OKLu@i})@TkJA%-NsU|K^zTA^;&=F$(#Q1Ls*+fZn~zgt*EZu-*}het
zfH@tl6u`kkvnCHND#tdUIUN<(U=wmWDy?BQ6s{?O3z=L~2Dbt(_710e;d<ffaIyTH
zUIQ1$I@4#uoe6gq+*xqvz@4K`JU+wycHFb{;loH}wAR3*|5O0iTEB<2hPHghU~T#M
zK78cUR<@v7;ZR1DD>?HT&r=!gsqs0oy8u;Mv@KE;Z?<r5)qHpnE`!K?TqXJ$7CXL_
z?&NcnC$0X+R7aEsrA049fHO16?r2k@Maj|-3v?!KLE^XF+DLqrz*d-=j>ur}Qc{x<
zeJ?oE5!sg05jouVe4Yx;<)A?9)f_~=HO_p*(TCV+9J9|;YP~4akpSsiMS1UA$w^1(
zg}2?V+LuhqZQs~15FPBt`@3Jid6DoV7r$Jw<P6keY!U14gnGcCUt*T3BGK~^6#mHm
zJS{pKq6a>_aPWrmfzSJ)B;veU{g(iQ6Z>Zbi0CI)?FA5`9rzZ0`9rAL&fQ!*GKF+R
zx^Ta~O>U4-3y19iqNy;<@*9s)dB93Ku^P3YBkn^IHbxo{tD6tX4uuXA80ZBoQ#-XN
z;Rc{w_ccnEbMt~I)rdsvg_{T&cZan4f8emym{FW~9WJzHr{C3X01CPiEB?c3M8i$&
z$7SS$WI5d86Ir6=z-9+H$Q=n>NovQ9V_)S<*ag4q1{8Iwc}V>C6xU@#R%}By6^hq5
zLN?Wt_yOF=m+m7wBk%S}+>8pTb2>n%O%(17K=Vv2`GDXd;4D1tWM{ke6KfLe@DkUh
zvyCS+x(>)z%xpTc*$wwid?lE(9USC1t#kKgAFSK}k=JNR9DxFgXNCdh`kkxDuUfPP
zMI$|efR=cU^<ZO%q_v($*~E5iDLMOzwtb=5N5^9>#zyTq*-ve_oi<k1f+s*h%2U||
z)S|C4@+Yat9%+oMZ@uxjlhcyOKO)kxZ0Kd+9y$t=R;r}7uSGAWlvZE86P<2RAKS*g
z1!n57aqmKPupzguc#KM`(Hg$gwlA=n(PZ6fnhd$Z$EW3QFT(`uO8{$U5@UBlXWfUA
zW@H3Pa<qI1SJ~Rpei#-|Y|@2$RqA?y+>1zEc*4D^-xCAdqT_6$-Mhury`o4W>oJK^
zHXtLEpKVw*zzLQ%^z(;GNfXLc+>59JW=Ld=owy6GHCmNty+~yge^z0-2}CoMKkHhw
zfM;XcWMhaiHlpeM!$afyHv(egdk!J)jqiqDQG)LZiBkBER{kzRGwacBz;|lVLGe9H
zmCwfa_;eGQ_|8WQ!bS(8Y@e?k8sBCDV&i)$A?}Uuwq8+!Z@WY(e9uyT!FTQ>-+*r|
zOx6HpcK-%d`D}boPdAZ??-I12IQc+?F(mx#aK+Dfkq2Gybv(V1z}Ptdgi!a!`Ga0j
zg7fPVrEu1jUvR$dk1VYiIfJzoPhW?x6dwfVnW}s?&c1XLnK=KNEu=YGoynhx-3!6j
ze&2H@-}Niw%avXoW~H&)c%#>dg9Ka!b59g@NLs@`F}fg1N5fVaz3%dr#+6YLw^g(y
zai*$kxW-m_Agi=_1*&jqdfN6%>STpA_1JbT82ik<NH?BBt^_BWy4Byqf4PNYrn2IK
zf!6RN#J5J6iY>cz+AOAxmo)oSUha!N&srdhjNOY0@Jjp$yt_vom=9bgkYYEZ)t`h&
zr@Bl`|AS0li|Jk8{hCr#5?Bg5&wIH0Y%V34P(S;MThMsz>%^-3(q>~RNrtWHUDk;Y
z3;#%Os{0ABh}w%cwKiKHBgxpMt}@w`0D<UzsLbkXr(x%gSVj3_FTR^W8kFy}zjzIP
zP9b`P=#FW+fu^{xq3D^|FMI9e|K7G_FeN2h;2}^iB;iaR@#FeOx)Su^yjN5uuEgI_
zNu%}CKfuxtFF22i0!q#p;ao4i@pW{HF|v6g@eCoS^&0WAX-?{Nzl{0Cd4JaY1u3a4
z?#Q6eP!Q0j?-x{<vS5N4U=%gnQk(#DIV1=JCNKC?dZf2Kpa*sJvIh*!<eQJACF~Jj
zPVr9YS%*DWWVT3Bmf582eke1A^f}z7Pj^)I6C>&c2#_(d48S?`Ruj!-mt=p>CCfgB
zB!ba*`jCaRC|vw|#D0?<IOGV(Aou6~d+fk}i3%}#b9cgMh<4y>#134>e6}5UC$iXf
z;IHU0u>=2Eh8_4mD*($6+YbDNm$=4C+kto4#7x_P@6I+X<OVpmBC+Zy192d)#10%U
zaNDO%FfB~+N6axSDS^~5%7DZRIV!n>4x}!YP>@YHB9OQBddF}P*E=SDKn#bmb^bCA
zX}N=knSoKpGi<C?ZdkajHkB@U&xD^QH0;@I6B>+1+g^J!N{eZhtje_LM2u$JT>A&`
z3gHu{XAJQare4a&!zD$mwb2Y7#mE8KV6D9bMn&j8?37-iY_lsVunX|n7}0?6wY)B|
z*4~pChe1mIRcC4<0pP{kJ2IXq+F)?SqqS`qkM>g!d}4BDZYLx7uDB7Y02V@D4}n^U
zD%Cu~N?DuDqO1*bL;AUhNF9LI>i>Y^b*rh8BCwowrOfY#U{UArN=&Q|Ff2NLYd1HS
z&GAK{p!tW#Q2GTfX?a9@^i@2T{Tg#~=X?p~=8xd0Lz$be)s}3;K7TC3+&q9vL`8=s
z(T!*X=H_5Qu^WQ9xl;?x&DUyC&Qv(lwQ^7>5k*Zl)HWg0)Tzx#vsv<+tj(hj39gye
z=EtB0o1$9uE4162*x6LRAlGvjyKbg(VTEhq@W=+Q+UWB0^M_wQ&W!t@QY2<(LcNr7
zRWO>v;dTyalem+|Cidlyly!N31-xxteigC^Zz+@PPss>UOA%|yV=d!VEnCoyx*-Z1
zpDnTHZ;tJT;$H2@=#CXW^&1-=VF<U%!cl0?C(4Tb{s#$S<{e;X+-kqU+%}?a^=ZJ%
z6+SJUiAPXY6H;w+a+<KSUh5Lnl{gv=IrE{D;75XUqxmAte%3JTgdp+1B!{%<Gjfth
z36^*aUfw_6Y87Eg-u(xg>U^zbrjS!4!x#J6?17RYG#HWrVgb?tMi-Q>Gl36YW?Mn|
z0Nd~k5n(NUJ|)4wcp+1QI|KXct-@taq6}BeX)~p=3U9nq@uRrl$M(rubt3T-uvmIM
zrq<)F3prQA{APpovtI+Dj5YXZNCs<mDv~{g_iGusDHX}C(xOd_T$74)NzOGCEV10_
zH*z;rsp+vnygv$tYm4Y?6@}&2cEk&>)qS5@cx&}U4Miuy4iP)7e1q<?Hu3TaI)A%(
zXTe*!TD*LK?xR)W<@<9><KpG>bMs!LSA-x!w@RK!1DlQI{&~5iLB=w4(h3RPr$QZ=
zO;K){3LU#vLX>~Vd78@kv<iKfJ7-1&eap0V)k0i_R>7VWY3(W$ROQrw$~{T7utlXc
zVj@S*E)_aOm9r4S*c7#g_u(U}WeLZ7>*_;kC*F@z_BD;(_tuw5ipn)y`B~P|L1L6<
zuW>rY`_C$oU7;e*NS9O*zf?tbrHVvVgopK6jk4-jARY*yAz9@*8Cqo{&c*tqszgTr
zjmj?oKKiRH03T6_X#j0_SW*G_A5|m`;Cm`U0Gt2-S0F1UJZg_EIGeP|sMTMBslEH|
zl)jx#7|Vn^(%~_p12|MuJIjfAh|GAss<AP7{DlMDF1izK_XoCnl<n>Y&`f{VcGuhP
zD%-uoc5k)apV;n&wmZ>we_*@E+U`)>?PI&U`>S?3ZMWHWpRnCu+wKjv`y<;u&vwVz
z?kTo=tnEHw<MC_Ty~B2IwcVeH>&R=~$Hu7wZdwky{sZtzKJ-N$Um%m|J#^E`JoJin
z-Q|ch2h}h`H#g|aK|%N>kM)-9*ue-&9{GYiW^{>FD`kSPjWSv+b@mdZ){uJ`Yxz40
zN!^HWGvbR`tdAdSk{kHBr^OiFn&g84>f`TGK!P~DKVwZ`S7R2uC$2pg-^)UH!%O{`
z4rAA~*CH!EK8}|cM)KRdxz92phWB~#fppy{{3C-{yS=B%X3JZAb7d-oGxqC23Vd3s
z6rY>bWIw^!k{sR&ljrarSnJ<KID}<W@AZ^#>+WN;#HQkr!m~C5gO2bg-OU;IU(MXZ
zUgN4U)K7i6uPt{^r;@SVQDTsKU)ighBd;TrD^B_SJ7ezu9(<UjJVFDQW*?#N#s2Kb
zOPC`fk9u9=yO{DP29hTW>vQ=npDXAc2d~j)yRFH>8xUr$GGlGB@bAob>J<p=)>i-<
z{4f!ef1sDYsT*JE<sa$CwCa`r<P#vf^t~Orar(Av(4vw1KAnt)9e&bRynKnLb2fIb
z^%qXH0mpJVWuG`56Poca^wM1HE`x+4fPJ!XJYh0N_6KRG=)|UPVc!>ipV78G-yhid
zvFa{Tp@LL^(T8qM-$FYEERB$43FA?|Zz70tiQ-F~S)lj-f>xOE^fB<X<wiEUTmy1k
z@wVKb!zY5r$h{q2Wc~bV7Ovg}uS-y^?nxGIWHqrtT0MbHAdoD4udmy+ik0B_ELpe~
zaaPHttf3l*ce!KH4nP8{<#qy^v>YOTM)vm&9f8kW4NJ+q^!Ea+i?C&%j<?@C1TfDS
zuoJ526YAH-!(&*|_6ZG(?01K}smy%S5dA;$7RYGYN7JeNH1v*+*G0f^eJ~CpE%+wl
zr{SHMWvm1av$|K>`=NMG(jH0ncrw~iYr6mN_-C&SqMuagG3ZZ}A~1%;Z95zn@gnpb
zB?+cnLRt*k9ifV$&+@JK4&avqGHdh2q!?^Ot<jQ6p9M_=Cyv&1Bv@PU4{uIkm6&cn
z<9*ASdhM8nZ=eFU%g^@I@6?ujin>9qYY-1B!U(<rX#(X9Hw+JA;8){M-VEHJ-A>IQ
z(u`pmFRJ`74578v+6B@JyS=1E-(x+otFOU}d;jViFm?v}jyV!_28`+gUt2X20bki5
zY|%i8%=fJ*V|I53l}``ypw-+DUneBN5`1Cq)jsG7bU_HaKmJ%vJo4^~q0td5C(`wK
zs5oFGf_(?AL2h-mj&?mbQ<Y)71O-v9B$E3pq`P6KC+D^NR-J5C@l&FSt1berI}<<P
z;4QoY2Q?t}m$ze0-fUfp#RNdPjFqEWJghqCPe{Q>9!l~ox$herbSolwqH+rIHa1RI
zAN=97HZn|SnIn%xX~;iZ2HAlHJe%}gdI`=(>PQ60FAQ1^A!`cBcb^{1@#1go(TLI`
zUAwIHpc3Tiu*Gynj-XTeQd@2dit$I*@nD#&MwmjT6ym(6|NOi0f8hM@`pxg~quTY=
zXu)qz&A|sLwE7AOOu~1#*M+|Wp3e81edSq)QAjW+<>1moJvZ3Qsd*S7@MFL*8(3e9
zoB=A~g#Xz^<i=|{0xu8<k`4vUzS?tB!698i_ja7B22E(qK2)SFLO)>0d9>)y#N*ZK
zFNG&i8V~ZW|Hnbt7x#7h<c6AVRCid@p~Txw-tdT-`xfO7K8K1qYYDdz0l;byEf@>G
zjMevJ@OB@m_UG02QH#zz{ZSOrVh!v-2)e$x4<Kw7Kx(|Ln|hwjamIcgwxialx;>Q}
zMy|<tp~IYR;ZkLX-^?k(!o2(OwEjdIu&V*W(-3ER?B^YVx&7fdtT7=ZfPY^%@rYq*
z2eRGp54n1TGw1MC+H-i=^W%Wg8CbZUgo}0tG`&+VZJrp*>7#DEfG9$Rb5T0MqknCA
zMi~^EUEjM9Itcp}s?bp^6er%XLHE`H!nW!T_L21q+Kk%uOdha1s|x5XsVd$?&cx4I
zMc<LNoD5=vo?QUPtU{kw<>8rr%a1G^Cy2Hx;CF-`<+JG?`wN#Vesk^E7@Qk_hK(r~
zNIZy~uy`BV84GypwCES~<}$6G%v|2N5+eZX<nz%Kj$5^8IZ8<HK;?5uVzNW66)=31
zJ~Q?nshca4o2$m&ErEww?^1Zf3s9$MVAt4n!iWUl*{kmq0Ur9hBqlpkb$VT6e~EIT
zE5~AE7+>>2ani*)DFspkf)qu!NCLr0T#Zgl@yFPaEZ;U3+D|-mbZVYx5qYg(***g`
zzCQp6$Ep0ZI54h5Jn;sMTK!B^no;ISq@gJ{V&#BF3aWGgFs9PCqt8^VQ1WIKyMY{J
z(<`MPd91(oM|;LvGk4jmvJZc}j?c?_(5d&$r(9ZuSdiUi-GVM6%EKLOJZc{jec%Oa
zjJyTxh269pkbfoRILwjvVEFRm#qZ#@<4O-nX1p0F-GLB1-6ys7AK*8BoTFo~nl<>+
za7(^1^*??2@rNG0)Y2nuc}CS2##B6q{FNtk3g3MQ!&U?^gxBI3W$dDX490Gm*=U#^
z8?*;)CkrdUP>J(NI5ye+KH*dEC7DAo$(enOriI&)>{+<4s%nA<=kLfStg0<0Hwn9H
z5pWduQqg~>-0T%r4V4O;hW!qU9z7l42#b0Yi-t;V_7o)$y(6zp`B4%1L45#O@x(td
zpPaB!un9p&RG&?iUHv+=>$3S7lEvZY(4Q4Aw>f<ByJ=42%aMyc^Jm4!9o-8X_l(Pd
z#6AI7Ca%Z7M&W1NVS`_ITC2YeUWcz|*j0seRHH>NN0QCgiBsXn`HIu%Xgg>4t_-d`
z0+ETskTI=aWbov^sYu<?n<M|lxGkwT8Jn9BXT6RNPP~W&N08XAbH0O4{;PEIANB!f
zb0qtYU!2D`dB-&FXVlook<w@mOum6j0?9YQEQ9&x_5esNFxDqr#ax7k+qU8Th}fVj
zSzJ~gJW@G+BZ{i|!+wv>%>5p6;7YNv85QySPh@&%a;u6!b1|H@t_R#88`fu`vy2Me
zm`n8_Ux56ohY;ny!+wqp>Y-zd+$2sFK0SFEnv=mVl?uyrKd9Olel>HSL|$V9n%3-m
zj=q5E9!DD9iB(P9#!A5gN0|kcuZ0J8Pcny8z7;Cv8}p{lck03)p~y{A#6ppDb>w(L
zIi&!`Z3WiS^90tQ<a_}+yI;q5Q;^n#<=)|l?fyq<JW(r%LhW(g;DIh49&F}*`3gmd
zR{tABro{y4W#+zXCqXvj8?&z?gn<)&3v1vw{M_9bqMH{KSVIXwJwJjS{um&)FtIK7
zJ~;ff<=$)il7;u}1vL1;CN*0#_jbgC0EbJnZMoMWNU^2HAoTe`w;(22xQ&IjHClgy
zXi8i_o|W>}0}Nk*u&uAx`p(kbP37^0l{M8cTj}#DUVomw@Rp*1eXv}{OV<l4CtnyE
z05xBg@7^e<9;x-2uF7l6eZ!%dxr?;rfqp=-6faThv3vtBMz`brU2lG%vIF0|yg9Eg
zUgEA?e*->A7BAsDy6^EN|BUrQ>V3qG)-P&^RZrf{c!9F;w4cjTZ}!3;0Gy+!KiMoQ
z&$XmNjk>YPDgkz&&|7-#IN;W-EguKiF75-^#`QydGhPOS##x6`{g#q$eEPhlM6dij
z^qixP!N75=m5;{3j(7)uOGabduiJrdp5^}WHiCl{;`-UXg%toP58n#l0BZr3)}t8L
zXlO^E)_WEJ3YInn+<2K{c}+k3^A3k567#!?LNDVLb3HcvZV;)X#MX~Vt6*hQ&}hCP
zk26H&rW;12XoVJ?W}NvA*U{2Z;19wFa^(U(_9Ll<2?uaF_A8(dj|>2wMf%`@sRH>l
ztKGjgertdBP58BehaCJAX1a~pI)z!M-Tl}%XfN60J;4L91Xc7{ofxC%`Q*5jflXST
z9t<DQ`*grl-f7bsUtz$~RB(a{*JM=)I03D?!%0ZjXXEo3EPEje(%qF=z6TnlgU&Z}
zS9$O5Qu5>={e>;46mLs2rnh)+N0T+mZWFzf4d2M=fRBgRMmumkvo}9&wa!lgIO(jQ
zd#kyy5d$6&Z_}1f0c%ei;tad>sbM#5Jva(2`OS&or*>Rx1V2p#Kedyenlbh|!|!GE
zfWuGt2yJ*+_rEdN6@Kzeb|gOB)Uiwo_lNp|er&_)X~Dnzrk+39jZZNv##i!W+k3s1
z`;Aj-^s%&`<qlHO4M*w=6B3FHaOq>jC#g4oz%PR!a^?lSi>voLGvY+*WrWec6#)z}
zZr`ALAq`f#W?_DP_6Uvzd{91Xeod?nV%ALmP#&j0FkpVoJTDK66p;Vj<N`c;OY7?o
zJp($zKgR|V2#FQ3w!A8@ytDfR<k_EGphfGPNammnHkw)3<y!dR*<P3Hco#AR&3lUB
zz%-)|SFX5X%bheV*7=scAJY0~7xG4kUmcKEOg6SyTaOdaXNtaA-#PC=R?iiW0I;g%
zMV?+c{bR$4c9Y2k1DZn`Gv^>P-UE(9KVq=2Qx^8EKSsXH{TcgxO=7>N)f>(;tBNbD
zO6Cu(`?n{29E{O%SAQ6u6hU+(?luq<RWE~o&0$u}B+N@$865a}eGk|hjD?Cv^R1yW
z`LY3znqQu5?BdsQ-_udawFQ-LYq2)Ki@lkK7vbVIc%`M?1q~e^>&gf4uu`3WejxHv
zA5ddj@mF@~KcX}~l5jRed(h|(#BR&QXMf56knV2ng-KWx@3sn1TCaR3+#T8J?p|T1
z8@pF}P`ULfgd!S?)j$*&Gx8Vw8<=|21_&*s)}HYLV8ouUz6gwl;KzL6l&95BM)~l+
z6I0Qg@wV)<r0HePZ$5J#RE>@J;svbT8?aU9s(e$6EriR*;@WPjs86<43A(ZKVGjQk
z5-?pI?#BGn3VhB1K5toGG^tm974GgnBQ;)2d-hZT%&Pnl?C4Q8+)hZV@}2%bIfZXu
z!dqqIJ5}K;>Y4GT>^|D_g({tfKUKa3LKo!?&ZhVpMOA+IeQ8juC*IwU0(`WP?0zgu
zU%+^+U+2RWP$VWp7y%dy)#l8+Rt(@V!PpeHFY=xTf@z%gT+U&Uu6O(cwp2Cb92UTL
zd;*bueZwCFV(0bMOV?X}L-imBhB%A+_O?(B3Kd9&tn7QNtoyINJuP0ori^A7i*bk8
z2U7Hsgn+TWyFu~8bl<epURGJ;mf>I0s5yEs=nq+2gnfw6WqR%S;Q`})NO?^*td8W?
zK<P`tSoIfe)mW0Tt1hNA+G-6RFKjsxG(z|FbyI&x^J5*vy6|HVwb`3xuqOjYorFrP
z%aIKJQk!Vb_rFuARY>h_ZM0jo{yYKAn!tYY{$OnK7wX2KHMmOJFVL1x-#^=!QDlrC
zE}s;|y^W%7EGWIM^!gYw-FOAdRlm_1G&cCmK)$x*T9DLN*{<CchR0vp<TC>K*c3rb
zjL!j;HlfTU<XZ>vgsG=~4?^?L0S6X@^x2W0d0Zi%KQ_M4su|O#Pxl*fUsKPhz4#Pw
zGdH47s9!h#r}zeT2LwxZfy1ACfaGaa8+3$EP#?1SAq}Dgfo-fqT<Da&_>eu8P+=;X
zh)DOR!{5iDS9<X`>Ztz<>cH}7&r4V{>hM2?jXBzHn^Q5Z%^!xO<5}xiZkcP*yOF~0
zX+MD82*zqX&l3&px&E^1$NO~nHhUWeV>`#<v-@E({}Gl6NfZ(SY*qw#)!4Onr?Cr|
zmo~?8&Z}$<KM$Q!mW{Ny`3K5%|0zAbBKz>^unDL`i!CLC*YC0Az)Fr6-1ESHR<G4R
zh~&gO_{SkxMusUvUFaQd8ge~N1{_1xXium(F^yHCzrP0j&-O`CCH<xrEZ`X#r2!9#
zK$XYiEMCtovOO>LGtuSIsQ7^}4d@8M_Xxt1s7D_CarzUm;?4$_=G@5OICAeYstS7b
zmjHhwN<y}UKT@B7amusiF|2tiYo3O-poJMzd&x5?f2v@RA<q)ruWkf;kZBX+K?vf{
z`aG<!FYC)85`Zu~RpeZO*og{*0O;=t?X)Ee;O=<|_f&3zM>-X^nc+>)pa}F%oCxgD
zOQ_YAxL3ttE_#&oe-d1n_ybyT@R9Qm+!`HMunmjW*SHPc(13zG2`HmZ5R^-*+it^0
z`mp<7!y}P0`fyx=gDlY@=<`_P_TmZ)5`tL%`xf@N>L5<1;urw$(cyHW**ca2Vo(a-
zVLe&nf!j<QkAyOWuAY<rzSXz_3;-N0@PA@9FjG}-VU<4wgR$7JGK$G8o95r?JaAEy
zT#1eg`gN$rybxblyAXTO@S_7Z*KhM{ffipRegvg9l*7=#*^yg4V6a_avtaGD`GMMa
zb>-TCHhC?i?9n1+pTRX0NLh&Ux?t>zVh>i)kQEI<j8tFUdkg%=rF@P<i&h~5H+NxX
z7FhYp%jyT6j?HwRKD#kc`9<h^I28zecXnhx<kKkZ!39gZ^!uUhosAQjNEarT4lFzS
zYEdtskt3A$Ky02nuy;H1^u@~YZrvS+z8Y!5OZA<;2JE(M3O|Z(%HadqU3zJcdkcCW
z$2Hv8#Prf1Zcm!uA?;ed$uhmNDf}reH)2}o@5a6k7RX<O`?vNlqfDuWj&p^o%;#Q<
zkl(mAfBt!(7RO;I&j$sDQ8?*n_#8AP8KLuq%Q6&@`Nt{!$I(ytefx~$1^@P&m*$b0
zc*i?-nY*?Bm_X$}ZahiHS+({8R#>~O?Vvc~!aFjG%|9xo@H8ViBLxam?8?U=GI-#_
z<DMvc8_#pi>*H(nx<@BCU*kPFd!9Z)HTu171M`B+511H?xQI!gyCcCJRhge6?|F6O
zbG!@-R^;T_+TW8n4}NF8Y;4I8+4Z~82!Yb6#hrth=_nS9P1D#3GX7Ka?*RQ{w`p!$
ztxW6^`1HM76VIaUpz%SX6fw5G7Bn{U(}=zmKb}2%HkJu~d>OEItFLL_DBoVIX@4JB
zURRg4s}}}B#lF?dCiJ&wJ${DJx3?QPG5aBN_ycqPXaMT3eATA~_r=cdQ`xa#strm2
z&vqD{K3VEm7jfL4lV^?}{lD0I53s0??|=9%MM04ZiV<5}6%E(|iUlQc7Z%)AnkBYa
zK#HOW2#aWp3N9!sqF7>!Mr^Ss8cWnz7Er_vqQ+=qP-EN`3pT8g_j7K6^+vwm-}8Ty
z_kExD`JrdenYnYPoH=u5=1jTZJnq=g7wT@v>yaGjPWsWOi+kd<n<^_<rjiBOAqcdN
zpu0`+&;V{l7^ZR`bK&db@A_v-3|b<FCsq0f4T$+4=$|~?Q7zR!9%lL{58NYVF}|Uh
zj>$eD>K7Q}nKFI0nRX$0qZho)Uf|cWagN?xU%I03Y#J@GQLZtm2yhv}ouWjpL%G9;
zq#+eVjU!4;T9ebCa-*G)>k-vjlTCxE43{Om`0L9_Q0KVpVrDeoZDA=0`sxu)&%BKm
zpVDj^l*-Kj;qrCBg)n%I0^q(+XxzufowTp8TH~%oQtymFsBj~kcy8cAP;P$5^*&JH
zLL#d_5fb71BeTd8A(RwB(|01kw}`N8Px_jEIqS1-f`hEAKx}_i{O0ue8Po}~kIb7?
zTpJRy&uRBC2vXT9ZYadgZ-d9OA`I(IO+lIK_raou=hl1WKRF}e{q^yqdl^Sp&f=pT
zO8qJJt6Wkr?7ow%D*q=uWpuf;=!&_zlGR+1<(sK~=wUX!00jsLkFryT=PSK_h3Y?6
zrTX_{Hy#$}q5O5P;?QPY<m^{@f$1l+oGy_Raq1z0Q~Q^cy4&(HJ57m6m62G9AX*nP
z73IrREelmy@$Sl$w_cNP=nUN{gsl+)GJGpxAou#6O>0Fl(AbHr-Q3E|6_pG%&CcHp
zk1BO;2~BdPnjgrdpw9~heLeyqFv<J?acLb3ETPczWoF^AIP3NTCrsJ-WyrgdFO*6j
zWyhw4A{`tauQ-O2y2+rGx_cIWxMyho6gVhr`Zy4J7#V1gn)-?#r7naYy^=lvM0Uk7
zD~wzyJZ9OIxVHk4AjiTa*S;L5ThSO~u;2WNe#I{<vXbkSRjk_R=XQ@6F>3|#Rn=c1
zeI;fyl{1?1`b>-p-GtGAdeObEOezy6Df~)5Mz=IjetuVfg;VFU5>so)9aWy7;Mg?E
zA$LyxDy>n`Ed-bp9)hGn#!IwLNL7_lU!67FqQFPy&Ms(654?U)T$*jxKPhRGrq}NY
z_qa7Mp+BHh*z{>g57Tw<aS|w@5=@bx!Nw{5XeQ6`hfTW*KZ;}%S4vZJB*bxg5ByCF
z>7o9rX(D{Z_)~9H(!dMD4HIpAM<FB?l0Fr05!Z1sF}nW-;Qm#!`o|uU0w3!Ci<6$<
zvKq=SF05%S)7BF?VS2<RTf+0hWW|@A)h(rXIUboRK=Sorw!Z~OjBQn!{V^OVflZDx
zG^wz^riVJ$C=b*ZQH!3bw9WO+vZ{{@PM%+F^R^Po#`aY1-4?ca7{y~gSCspLrVr_~
z|Bn4pi*GkRLhYnr%uzeFpA9hX+D$F3oQdBTu#&Z+9Tm;77CJtRMoL$VA40xNqwsQ-
z{6wYxNv5(|RNn&~qEa7J_9ngTu6t$A&N+^dSj?Hin(;?wnELvFJyH@j7!(`bit#yO
zO$jzxV66NDy&^LlU=f0Qpe`}0Fk)9j+%Zsi=%>&3)8{EuZ;?zXbvNZ@UGV)P%pq%W
z6GaCw!wU9y{Y&jA-78y7)>PSyak{+jDq9TXFrqZDX<s0#uxi|7@ukpXYOjaMj@VI>
zggqnS4tNccIRkfR2V)$9vC<3KWXCKRV~UN~oCX)@q{kkH^b1MrG+w6UI!Kzn-g$D$
zMoLMS=U%pgD?KHYo&tpfo_H9D7qcx<JsuTRMZvz6`Iiv@o5EzUTPQkVH;bJb!_Wf8
zT}hj;p%5;x3rxf)Tt>pCFGjZMjtn3+eK-Orb)^b6J)YtaCx|SrH{wnfUBwtecXFul
zE!|=6Ylrb_TXaMgS~=J4U>G6HD6jL+g=rxfiM$??`L0v4yNNcsL}kM!Dv!cP712d@
z($=q@*_w<NNDTH4uZL_J9k){BYBBZ*t9#jrzoJq1vV#`a5??ibfi%jli2W58o-QY#
z@>Umgej~64%z|E4u}80C)jZ42A|1o9JT^Et^(GC64$znjhK0r#R9OKIwN&~m%G}p2
zo}2W=xi2y5`bFECAC~D0Y1GD#$CSEbGK|UGPGJOp$B#YwhaWCgnok<h&+Qa(6MB|S
z$Id-)^DY`Rsz97S=HKO5SIru#I<6|xlF&M<%7gIS{B<$Hn-aK|EigBgi@~94&i$uZ
z)r1(s@l+)Xw?n(5(y7^_=ZIUYFsOhMq#2v=*<_k#`s4IIr>(LDYk}zwbQ3q;&1!gZ
zB-c1SP8w&TO5T0>h=rlDa*ESI84x#K)nBGn4m83FaGPtS-(VDJ8jl|;zG(qB3=wAg
zM@@Ld-I-1DoJ0Y83D4!=p>Yj8p8+3C>`fXxMx3Tra1(3MKGk|7o7Ng`Q$zf4=}XS{
zQB?$FZg-JW70~juXr4;F!-OJ*hF#Hy&`9dZP)Ljs=#F8$LRT!&tQz-sU}Fk45OKG9
zWD6u@)f1-`(p;9n0|{3~;VPEpeDGC3^cRI&vvPnDY6H3Pr{BZfY-ZGWBIoGb>#|2M
zEO6Jou$XLb)FLCBW!#M(T5JBx8yKj>v->OqvNpJ+;C0*@lQ;sg2)A+JMkq{>zjTSE
zBTAUp(}W+CT&1r}Jx@J59BQ;Ln3u8=VfE6^)V*wz6w2=NmEk*&eoz(FWfTjB>oCkp
z9Eg6~j*i08IkBveQkrogx|CPL**OhKu=ib1hY$J+>hx~qO;KKP!JpB12bF<z)OyU2
z66qbN`P59F6F8bjl_H8C_YoB|4hwW-GIn-7#H-0n!nAKXrsJ^qs4+sLVe7HZq*XC1
zheM<P%lOpD%O@CQaz+)1>HDQuB-yKa@zuwst;FlNj|TB2+0e<cDa1&uX%I$_^Nco-
z#v8|C=1{hmmml3LYfYvf<_CR|6)sb0K8OUAg|-fUF|S_>cjgkVUNySoHhKrsWD)}I
zeT=w0jV+K_)G&AXViBUjrU0X*SpkgQkb9F7FJ-g)`pA@AeJi=6lio4-lt<QR3;0_o
z`3qh+|FRGG`1$bY#BiaE6@Jr@%I`R}z$u2;rh33&G|4U%Syw3EYz5&YH|~LiR8ZNt
z&7P<zl>eIRH3*LJGPHte7v2@}g9;bo_Z~-g6pHz=uJSLNEtI#W#G2Nam=`G<6%r%;
zQe$T8*7*KZeCLR>yz%pUs*#;w1=SFnmVhiOQAVmcO%`2rgsa}zGy{24)#@*?Y1XI`
z-OD6wsKaZVNaYzLo*>fiNwq*0(FnvQLGiG&za{k{aL!ebCC&s37G@v;W8|NBJsz*u
zSRRVv{mh?=X`jiHQ(*Z1E`RS-3Ne}!w%S!i+X6}x9w-!z_Id|U(Jt@-P&6EeY=UxP
zFAH6>nfszQ6@H3w3$(WBBD5#*OUK7=#mNyTL8b#px@x>d{@&f#w0MY^cNaFz1Z*yc
zChq>#>Pp{?>B442z{!;IH$N<>b8<yel|rMr&q-~+8~%0;;pOPbP3`|4{#gy-<1v6Y
zy@rL<yuNCvB^qGF8^61SH%{V>s`5&*Hk{fK+OS+wluMY~nzHdC^b52KiG%K~B|GO0
zu}AmTVn4M=6{{*Y(Vk%VKxjrog3Z`G00oQ6ruWmSc7=*2yBh^Eb>S)qqq2&m2=N)B
z;+{3)p3z&}bCviUT_E@TIWi{9FX(+2p^_Ec!>d%>s{J-x{&6CQfAI*Ok;d+Z<zLe-
zSZA{XVG~UAhh|bfF96#s+4NILm1Lh<Q@TN^w`4QYgp#2(;Y-P;DO~btls)RuylvSz
ze;@?Up{t;{LSF)FmE6H<q@hhwW?G`t&lrZRU@uLUN?Alv6DR1p@v8cv&HzU&0zV^#
zHXSSMf1z7YgVEF}EbG9vU-~@7Bjbe|D8qeN<wfoYnKb=^a#h7gDIm|h@-!X6Bbws`
z1mM#I3h_k;blZ>?DvogplAzP_*c1~23p5^a>a&OO$w#y_7LbYeRM_esFryxK&|d8K
zp>$~|z!hjHQZef<G8|0)$R;TR>OMFPWr{(eQ)XItVwC_K+20NCzSHcS5Qhezt>NE5
z!#6dAPzZvLz+6hyV>>91px}(@7Lw4J+$jS}eO=Q<I1fVaftg+H2jTfH*ab;VpliyY
z-e@=6$Ux`)T`0128^jL1Pc>p`-anZ#%_2HZyA$2u!O2HeS#l_^P*l}<jYjFrI1q&{
z)0ga$u&oJ2AjS$Em8l;dVZ4e$LZ@+B&g4oWhHu%y2ip~aO}&r^346F$YiLN%S8>BN
zQz$8n@ai5~jr2+|>sGTz5GfzyWxUVsLri>h_fU%J@=|LSMC5B^#!SBuKLxSJ6qY!6
zpbc?V|HSy{I@lP4WU6<EWOLt(m3v&%y=*$ek=uzZGr*pc71GG-)R#{&^8OV|A$n(6
zfv~%mHo=PP`??oR>A;fy=NaMLYaZ7i!YZtOaj&ZzVO4eJ6TH8Qdtb%wv!|VhSqfYW
z>o4<5JE_XhSiwizPy+*#AG=Qt<99Cqz!nCV^hzy00gUx$exD{zk?rQ==Xy2tAeovs
zB{%hID|MFo4ekmw4Qc|ZK>zX1_!?{R9)`>Wr(Tn=piSSAVi)*Bda;hF&KmBl&Wd&p
z2>%nCG;;s2=$qx;S|hucSsN$)m6=v9&mWO4DL_?rVAB>*<>zVi*EIUO9tJGlSL-W{
zF5gO-+3$@X_Soq1tnl%|Q`l~Z4C+s6+zL6<gd4tynCqwad85fS$(6brvH)0mPWWXu
zbD@cMH|!{Ld876^p6Kd_cKU|aZt9mc6UU3HOzv0*_PF7A4D#)DJmH>FpX3yve?_}W
zCVoh*d`g@WT*d9gxQYN7hDFXQQ-=B48}QUBzzvHzMOdrRE8ozTAKgu|-z8%AU;)g_
z>6nPZ2xp*Coe!6d7MXqDU^s49hHnyJ{DUJFN#?0Ppw!VYkjk+h?~IZ;v3iI9srP6o
zP2aQ3;bicvQhzB>e@vO_g%x=H3tj1XrCvt3w(f-$JLfS>zc99J=?@fcH49rCD{rbY
zy|8UeS1F&t?w2DH$QM=`yiUxlFe<SHif*gV>Qfn*)!#Yyg|&J)))h2ao@rQH68amQ
zcH(3gRpV8l@B1e4L4ex@HMgR1SshLr6&Jn1S(B>%hxm*|Fa2elR=`+AmFb|&8jOZ~
zL3<m){q&QZl(~OeE7`-Uh0eP27D_j4CcvgeC}3lM*!5vJ=M}3T&cTpc#+Bh{_<os6
z*!(bu+<_wC1>;8AzJ<Qs9pb2l=IKEghmk_it~pcp2{Lpr+<6o3`;Iwqy>Dvro=C=U
zk&ucwfnyo?Hk=x|vg{z=e%=$_jSG*yS`6<@;pYnBvzBlj1u{(?kt=6*Gwy4S8Kjz>
zQ9wU=)W5jW(SItjyE^xQTz>&(u}YTl%?jvTnTpNE<rwSHT}ZjO@>7mofNI-3+AKlS
z8&@nL;c6N1%A*jr`^W5vdPjp9rejy|jjoIuW?cv;aJ`)z9xCF(8BUZaV&y_@<)0Ql
zW;^7<ANMhJdW6>C%Fg*3Wz!eZ+J>wCLT;%OI?o8=uB@DLgREdVR`=oqHKwj9@J_}a
z^sX)gz;EQv9a+P6F8o>*AjaeD>=<wsS*A!3m<;EXib`J&pHT8~<F+KB>tHkNkuoJq
zBZ-@smC4{M^dboDPN8*&xXC}pBu~*V3NCAQ{v&enh5;*>(D+c8N^HbI6L$V3nj-Li
zR)}dR6^Bjx-8_c$69_|R2`%?<-yp#Bo@@m$RbU&7*2P=@h@Ee&3y-(<ctnE%1-rBW
z$6HbADOAn4_IZ%YIOA37c~HcVOg|V2;X}0?Pp9&x@MTwMUErhGPu)6Js5QB|J2v`U
zyrIz6<;I<Eh2&7AVPtwAfrue>;lZX;esP;}1o|)0E&)bwa7m$<Dz)|Du)Y;Y*49qP
z*g1Kyn&O(QV=9bkym4>IF}l0tS9(lBNIwSBZ+b)OU6jQV_o<_9i|DvqS|>_qkc&6H
z?!m3<4bAF{F8Cxh%CrUGLO^D753~cMSZ@oWqyj4-Nd`#L1@r7F*->^l93DW{446a<
z@Rith*x}=z0Rn=8cShiYh$GG-%Z2Qmg(wL8JATL&!u1lK6yeD!cFqH&iS|#$Mu6tl
z2!M_dSEKTNGdr7hp-!=rku`s7fAw4Dq1pLq2#h9@PdTD2gFa2!7jx&2FH?@lqfAZS
zf!~6xIP4=l|3xh}EduhSJmP?SaQ!#kRb$ft41jczQmWEY1+^HxtF|ub4^CO>-Bq?|
zD3A-&2par|`)N-op~W%mx=rJk7U(uf-L++_O3P_QzpO#lSQ{!Z-9jj^m&{-Emzw()
ztt<8AbF>w9sljB8fs)wJOe>(4vNPxLAJjO>&i?>8M=oi#)Sg6Fc+|2$Kab-p5D7da
z+1o^4%%I8_#b#r_{~|UBd`1ug2Tl}5)SF80aMkLElu>I9<2auo#MfMQ&Shksr0^zk
ztf10R|4CNtj7@Mr&Ry~Sm0o^M?1E)*(|HM0I-+sP1y89I*g{R_EPE6leD#KCF0cSi
z{l*uF8+F?7SznS(C{4T<LrS;PB~~{Q4{_2;)F`M}odI9nt;FDz>PLA*PU&UE!?x~0
zqU&yK>xhX7-9t?F7~J<_YzPnT`-6A^*PF3v>4?)$|044<D-~{vcPm$BDP-6n=T$5S
z==3i5j0RO(R?uI%8-GCsK&2?%E-15nNWbt>%&y7B7bVx^r4_Sjt5Fg`W69Y03#g1=
zy0}w0l^6jSWlA@L*NN#)`n>i~y4dC{Tf$j|&<?pk$Wz7>upP;S3bAvib_7L*m2l|R
zP=MMPjk1uk=M@#c3Y=asqZJavpi=*0hO^gOHmJZ2f!$6B5xEtREfR0I(_)5UMthM7
zInbb7x7~+SDQzHtERU~GRd7NWU+_nVD$st=i)Rp@DaWYvw2R;%&0cyUyjXDVA-jOC
zh~Vbn=|!M2{jAWKRoDicl}k?E7=f=Yh03^F4MC}~po!a!(fYai!)O9or_{hW^>P(^
zI40Fuse9H!)jo#%_*f`*&{$!uxP?lFT_@YQ=AhCWu?Mg|HSk8%!1X5t{eyyGsD)=N
zFB~tq0`h#1AmQtcT+z1yylI}i;7e4xP#z0@2PLPFxns#Ui2)>GsKA35KH)xAw0tB<
zTZM=*#zRONadK-AnUG-JaSPL6G)_@}h%r;AhW8mZtqz(!RGNXrejHWzQ0kYwA1m2*
zC(tCU5B8y^(V-CQ??S^jegtC~B`0=S-lTM}4IU8)T^5_(6xrJk0|Mz6uKR=<qDDx6
zU@oUQAe<(;ITK=0)w<BGV6Uf;bWk6Si&W?H-%RTf4*CwF<4VGX*r<N!@A(xfxrsKY
zMP)y~g7nnn4bM>1@0gBJ;b;&;x`i}yfB5OZ8kwmND3WA%l6v}vc4u&k`rx6YR?=+H
ztNCO(bwbtErADlP;FGxD57hs~rdL8{kqhc!s90QX1N0k&k6*5GafYuc4^QZbNyB=`
z(3QHpCQfQhTAub@R4}q6JMd0HJI_*Vs5Mlu88I|4uFE(7Bpmjt3X8ns5q65z#g{o0
z7Hs-W<bk>*MMf-5roDR!dLeB%+CO9jl5r5XEiguFqz`wX*F(r9=Y;~XX*zmlvZFkj
zNTet%N@%<cFU-AlLh;lX5x8?wcGdVA)>ll9;8N<3WsP$;_61k4hJ@qPn9mvKamqoB
zrA`BP<1<!xF+?Y;8c8VRlr%^q1j3yF7^~%*uH%_8ic9YVk}S)lhMQzBwrF;~E7;<3
zUwOC%@@AR_DZt$WgMmZ|Hcf&3lw^-`Xrzy^LH_mI5yFfCTzwlWsez+i@;W%ZTeZrx
zz~)_EC^5qTBiZ?L5P{%D9)GK8Tz2BFLJRXQ!$ke1$UNgJBvHjSJw68p3(HHYB4Zw`
zq2L!)m8uu7GG-pfN8FJc1!*5S#^YEE!s;dwGo7HtZ=tr?eS<lRWJsA4^>^6!hh7DO
z$?gjQPYY6Bd8zSzGVLAg3*bAV3<qA#tV3mTeNbP-7nuHswq79iF51wh;W>E3D+ifr
z6gT`N?m>lzpxZ-pFe@zjX)GWmWAruZlrZwg_rcl~;wuOlji4UjIRevxP6c0BXcM5K
zsX6q5`e4)OL<^#8KG&DJb=N;3=H6wj5QM%x)0zt~EFU>124QwUFH?f=OKdPkSZ1mH
zh%}ES?V?gpe|#K9y$aJBNCK90A=)a`Sv)DTamFSj-bj2LIt$2lfc}*6XOv&?q7Swi
zlhN^!9*9@Dq4aFp9Pk8d_1taxBv=%tgqI!D1U%!cm|zlVDg0+lH;^!zq_@2p=eVAW
zAM%@QXpbEd;1rE%Jv0@k8a*mR<!Gi6g?JGyW3s|~s1^kcCAdBE_y|<mLh8h-%57Rh
z+ujg&2>LNsK?X1o;dVfRHHRT9+>)0&#Yjqyv>t}z>r~VjxUrW5jF@IQ=TsT0uHJbi
zs!+)eYj(P<q0k?r60mVqCiDa}1jb4xw$Ia$xLpwqf~hWP!0um(0VCC@*Qq3kj6=O$
zhz+${f-zz-YA-K25W!EAR%U0rfPo}M?A$n%j!looFKV=`HoMOUVt(1%T@5pV_7Oj>
zHthpnHp{>nS9YI2c+(TXN$Nw&9I!D4n|M(x;+tq6c+*H$zYvTA5QET8EWjO83~?Bn
z0O@icUT2f$?+2#wO>hBGq-^PyefOk(rZ(`PBBI4ZX;N$EHSBsQ6HdMI8aIGdy+9C+
z{+LmZCjqpv5@xFt#-Fen12qt+zs+6c@yJ*Q@`>$K+jM_<v1wM6+;Jg?ii}Qydf1o>
zWP$pJrnXQ>&?TIK&bSv6Ea*Hg*5jmhUSRA0S<DrZ>L^lf<Ag#kXetHYht9Myoua%$
zXUxF<AyOJoOvMO7ou5$qBqAP$_85wA*Z&vDpi_x$IHmwTn+`))i+ZCA#sJF9U>hU1
z<dlW8)A|BUcpoQC))0q)EUR>AZN~U1Og4f=@sUx6JVV2qPC)!21Jobqv2*ef4pb5K
z%(P*a5~7ObGi{<{M&OKCIc(ZZga?NN#t{F(9KJ?PmV9ZvX^kcp`O7@SjWf`C=I6r+
zA+&yjU6>?{JRWuo@(gt|wBA$r)8yh5{lKpHw|TDq)lnMFm|CF!qr?Sip_=K*nUeWz
zb5dxUgK>mVfbJ*&s&_P`nd)Mu5#KdsxOD{F23u}&CYJW0n>f?!BO20Tw3b^?%d5KT
z4|<`@e8lw-h9baqb4UWAX{>h<WR+x)F~(dnw$UsOk}-cVG43xf?FM|0iszT^xQA&R
z$|U5JE*yP_)ya5<0m+QScixEN5{B>#LyN8GUZ7X2y3d*Q#W5!Jo9u#5X`i>*fNv|B
zy3m{NK;wh3Rvd@0hH)8@Ba^0!ROeN4%Px3I8N=6L{Tf#&pI=t${&X<i_`6qI<SVmk
zs6VeE;x-+Fs>3xPO=;f>|EC<x9nU%)kfm`}hijbl*s^BrRX9Cay<B&*MPODlJ?xvQ
z+AlL}!H{lsl=7o5cKf-+7>G~0&OQidAWn&9y6az(IU2@wD`m-_`eK!Bxe^v=Wv1c{
z7c}`-joTAV*1*@0Bny0EdZ87@6&Bh_FapD1Om=IFvLNcuPxx}v`4hg*h?;gqC`aXM
zyq=(!f<bTc4eYitSY@iA1dy0lJ`AkM_tnoY_sz2UkmA5$f^@JSmqr;aXiu?|b{`)F
zjEiX$A)0%UnBH|nYDxl|&ChS*{5?(p_jg8<ofY7fm)I^-<BSbxWS@5C?9+9ycf+2N
z*BRtEgrEH2N&XY|&`DV#&iUhTEVm!rHPhM&b8dC`BMe})G3XK6VKZCOhq!mb4i;*z
zC#)>Vw0?;5J9wadK*9WA;C96>=Ka)z&ap1RGnmPPVWqtS60Z*X5j$^6;4X)oBSs^n
zar{n<{j77~2W^IFx6?kX4{oGavh0fZIB`S8_I>C9z+XzKX{L1&o+D*8EgI!7OR2U;
zpRgV*#8kG2!gJ?YIjh<nYX$d`1&lJZOoHv!)MI8g*C1--sxzK)x#|ysze-U4Id?IM
z!t8vuu%4qohwW2EB-d|kXZC^-e#uvODg2x|)B6<W%{UH)vgkfJ3t#j!wFC54r;>&s
z5%R$O7f7*8&83eo>=M69Ze{sa(&bln=^qgn_Cu#uqMu>ZEpv@mXiiAmPjG?qJTBfO
zidUa(qaSUj-EyK2FLHfoW`&&N+8BNnh{`X-kLy8vu=G)K3wbbQ!U{1E8s-Ho^lAui
zmeW^UqUg|aU&0P}*HV8$Eh|>1z9fSMJ7*~Jf<U;frQu)A(VoAATa-r}D$X{SKmPo1
zI&MNZjVsEg+StzQ2u^)V8ZCUF4Qh765@O6A{Nj6@s9=3FKwaEN$khq$Mw5STs)Z7Z
z_Vjuy5SH_X7_`|-VqjJu;{7O@lbqE0^P~kd;a5;DtT}P~#oCk}i%fZH8TPd2EA?<;
zxTDT3lY5<;d6T<u<At_iuVlOFjj_N(!`2aVob}0wjMxZy#*O}&eQdDGWt5@1xoSAB
zZHr|z2Q_*}wR!I-hryL*2l|Iby0oh7J22-Umy2ro<oKgM&6`1Je+pvM*3l1jKB1s1
z$M}NgSBHP+ytG^$KFlc~Jb_l{Fo;rlJ(+H=zk=mUP55<~SMj}Ato>wpf2iy=-43=S
zrDdRvu^*oXn^r=xXN`lF{22$Pu+0ni#(CXNWKU4CNH-S>=}ht?3{RY~(CZwO<+)Fj
zHDWbBWm=Iqrdt2#3al~*zrp&B9~Sp;0X7!j%j#9<HxTQ7hziF=X^D@P_i$leAZbb2
zFB%*p)vK|rS0)eeI-PvcPd^;1q{oqNMe?Tf${DTvFzkH;?Mkb92CaRWBb|@EYn4el
z%NqMdasG3P6DJD7W=AMj@c6#jeIcSeV4J`GtiA-tx7hRylrQ(S1$Gx=qe5Rag%j{W
zD@}4TQ3p``8h0#ZcBjj7x?#s$MZQdXkM7FGa^VcI$_up7aI5vtj7`DM;@3%7$~9IA
z2w$7I=*xw8`shBnun-cS^gY^}Y!S8j2|u9C=VX%sDy!k_Zv1q9d8X4WqZeO8xQYtj
zwMEn7uBhQ9kITkO<8v_t78`2gLdFwRV@%mfK3xr$?kA7uaD~#g(0wwP(q_{;bM3ZX
zDqNKf%XXpV%HhMm<cXmbuT!)io=`YXg6<V1P;b47q7o9>g-d7_!%ctadZ}ACZ|`RN
z&0Qga`k%36nHlSpTWO8cOqm)R*<V>BWnTF+aG*DZqTtpez4B*1H~v7`rUM|jE%7*>
zq~r5U3TJjc^2u;ZlmRJLIG;y7@(INodN&X!fFIInYjow#D*at_@R}^|6zv3Vr4zd#
z-HOUA1NFc7WxDE%1G9z+-T7^-CfnZi(+`A1hP+Xh+zs$Lk$eS)G#G{a^!=?^zu$0r
z0b5R#*fio~><P}$Sv#Ti)A2R4_Q>T2(U6cM9;Lqjo8+>xqgb&vjp6E!j@p>%r+{!D
zCzv0(GeSw8n%q(gv@~b*_cHAAw{R}Ah5;b42}wDvq^dIOsJv{nWsMEGLK$}+h_1si
z=eH=|xU0p<3tc_8r+`gwh(;WcrNkP&T{^K!lVt^E8&Jo&%vR%NV0E|%6;0g4C6d|L
z%UNq;xi1G}P{Q>;bXhCLd_gwGrer@L`vtKaUs!{R3v$*E#T;M=1{G>&&Ip5E+;gEi
zd<bR-9dOekR0jqWnf<}w;XG&Dt_HYa13(eULw~e*BNp;Yv5<c$xmfLWZt|yr`qMaM
z4^GjG%FF?HD<1<X@s)vQuUt;PrhZ<G{>OvHUV&Kw3z3@13eDG%d*6ij9Z`W$NsskI
zNj>mwhu8nyQ6pC03Uy;*se(=#z0kLk)`i@2Di`8UEUS7EJD}+D2Pl@^QQ3Td4_!~g
zs$tFt<Oms%)l8=^^vfLhCNRtQjURjXlv4Mog$n2WbT8}ZEoKICccH2DMIIMaZYN8O
zu+?Eb7fYuBUO3HPkZ9|d>H7k9jgq^{EKNg%D=D>wF|8b{Z#03o!F&e4$d3cMpM1QO
zI83QC)m3Ird!ZesKZh4oSY38IS5k_l0R1B_dW=n9C~@?`7HfJ~qxC9D9HPt|_*DO>
z1P1MsC3o~MZHv{U?YPa)u+O$EQro^LTY!g%I>{NUe5kFLRasTr7MkL~FD`c;C#(F+
z4hqqg?c#biVLZes6`E?HfIs8Zm+>NI1)La_B1xQwqrDt{`cq2o0=k)WsS1|6mANJ-
z71q8_(Vh9QEMf+A0b4x!d7KoghMQ|XQL=|lq1jS^tYO#?9paocRvmsS_olTnwX8G7
z%k1HR3`EodwScYrAAob*%@s8MLHG1T#U8q*(*IIY2AjJ!h^s=RiX#9eH{oqtg1FHE
z)6P)D-3*`U%Y$k-sSk0|uJFxTQkSOS`bG!4q97`_tLD*T{D>FJjzd&31^tGdENXnC
zk=<86?LvkFzEqFV2D`66cIy~q<dcN)w)uV{ZoEAd=Z3kKT!N)nwA4Uqf1N=f8fB(T
z$#>CY+ew2lV+%5ZDcN!$+2oliFlJ!-xB)J*kKxQQnWg6O8(tgU-$tWw?J%;=x|4~l
zhlYmDvmYTiY*m~AUyapmIse&7I<G+!{i^rRa__Tg+u_MAScA8?Ikx(~Vax=x@eCt<
zY)Z0>(%0gK|3WCVPr7y{O7AGXmYp%kMJXoCr%4tGIo<uODAPsJ{WRv80uLZPl1%mB
z3)PfMs%!(-Us9&1zUlUX%Cc;u9Zan!n0AzHcvPCE;RhL1X2`e@rU~RmctM{IrCh39
zg4D=I5YCNb_=+RGkYzQif+flN60B{+*&etQJk!;94njvP?GcbwZ_Hfi4lLopf`<Td
zblCx{A71^%D5ufGa=z#oM)Kp)A@7Xn)EE&rM+7)|2<sJXhJ&3+Ll?mm7^9I0Z1PBb
z2vQGBzt5%3rp+Lp(5GLa@sa{DYMJJ74H-ykUN#ovrRDfcD~39G8cT$b<>T^gjs7!c
zav$7^Oj%UvBXGm88wQOp>D!OfF|vR)<0S5AO>{ve$~7na5Isr+1Dfubn#RBUjlIgz
z`Pj3T4gaz~A@4XKkV4_W{PYT9-KSb;qlX^X=t`eY%bJVx1C;-7dHJb2Bl?$tIB$=P
zkWBy?DJuJhYNdKSDb$aeuOECA!Mg9qR29%OT=j6(K?`oEi6U-Tca5%a`Bbb9oYzNn
zoTlTr3y}m@9bBn|R!H|fVX%n}Dp9mvmee2$cR4Z112P<|1Ua8h6$hvwrWoNsRw1GR
zRP?GPF8-J|t+zoQu#SpdWw_G2GukPdo(-�jR0H#;G*MsuoF-i+rJff%%R^hm$+~
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
A-T(jq
literal 0
HcmV?d00001
diff --git a/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dylib b/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.dylib
new file mode 100644
index 0000000000000000000000000000000000000000..f6acabed3d3794697ca937ce325e2600f2836ed8
GIT binary patch
literal 106760
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
Ju6#ev{|oQx<mdnZ
literal 0
HcmV?d00001
diff --git a/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.so b/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.so
new file mode 100644
index 0000000000000000000000000000000000000000..2b9cf1b30e77113a78fecee889b809d408aa6b8d
GIT binary patch
literal 265888
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	~y$rNJAdF3Azy4fk%{9L-U}U
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𝔶F{>-#_$(#;^
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
MaR|$wsPNPOFX|og$p8QV
literal 0
HcmV?d00001
diff --git a/Ryujinx.Audio/Native/libsoundio/libsoundio-interop.cs b/Ryujinx.Audio/Native/libsoundio/libsoundio-interop.cs
new file mode 100644
index 0000000000..6eb09370f1
--- /dev/null
+++ b/Ryujinx.Audio/Native/libsoundio/libsoundio-interop.cs
@@ -0,0 +1,638 @@
+// 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 (302, 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 (309, 8)
+ {
+ public int @min;
+ public int @max;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ struct SoundIoChannelArea // soundio.h (315, 8)
+ {
+ [CTypeDetails("Pointer<byte>")] public System.IntPtr @ptr;
+ public int @step;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ struct SoundIo // soundio.h (324, 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 (383, 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 (493, 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 (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 (595, 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 (1167, 8)
+ {
+ }
+
+ partial class Natives
+ {
+ const string LibraryName = "libsoundio";
+ // function soundio_version_string - soundio.h (677, 28)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_version_string();
+
+ // function soundio_version_major - soundio.h (679, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_version_major();
+
+ // function soundio_version_minor - soundio.h (681, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_version_minor();
+
+ // function soundio_version_patch - soundio.h (683, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_version_patch();
+
+ // function soundio_create - soundio.h (689, 32)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_create();
+
+ // function soundio_destroy - soundio.h (690, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_destroy([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_connect - soundio.h (700, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_connect([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_connect_backend - soundio.h (712, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_connect_backend([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, SoundIoBackend @backend);
+
+ // function soundio_disconnect - soundio.h (713, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_disconnect([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_strerror - soundio.h (716, 28)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_strerror(int @error);
+
+ // function soundio_backend_name - soundio.h (718, 28)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_backend_name(SoundIoBackend @backend);
+
+ // function soundio_backend_count - soundio.h (721, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_backend_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_get_backend - soundio.h (724, 36)
+ [DllImport(LibraryName)]
+ internal static extern SoundIoBackend soundio_get_backend([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio, int @index);
+
+ // function soundio_have_backend - soundio.h (727, 21)
+ [DllImport(LibraryName)]
+ internal static extern bool soundio_have_backend(SoundIoBackend @backend);
+
+ // function soundio_flush_events - soundio.h (751, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_flush_events([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_wait_events - soundio.h (755, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_wait_events([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_wakeup - soundio.h (758, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_wakeup([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_force_device_scan - soundio.h (775, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_force_device_scan([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_channel_layout_equal - soundio.h (782, 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 (786, 28)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_get_channel_name(SoundIoChannelId @id);
+
+ // function soundio_parse_channel_id - soundio.h (790, 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 (793, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_channel_layout_builtin_count();
+
+ // function soundio_channel_layout_get_builtin - soundio.h (798, 51)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_channel_layout_get_builtin(int @index);
+
+ // function soundio_channel_layout_get_default - soundio.h (801, 51)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_channel_layout_get_default(int @channel_count);
+
+ // function soundio_channel_layout_find_channel - soundio.h (804, 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 (809, 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 (814, 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 (819, 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 (825, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_get_bytes_per_sample(SoundIoFormat @format);
+
+ // function soundio_get_bytes_per_frame - soundio.h (828, 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 (833, 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 (840, 29)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_format_string(SoundIoFormat @format);
+
+ // function soundio_input_device_count - soundio.h (856, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_input_device_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_output_device_count - soundio.h (859, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_output_device_count([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_get_input_device - soundio.h (865, 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 (870, 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 (875, 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 (880, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_default_output_device_index([CTypeDetails("Pointer<SoundIo>")]System.IntPtr @soundio);
+
+ // function soundio_device_ref - soundio.h (883, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_device_ref([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
+
+ // function soundio_device_unref - soundio.h (886, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_device_unref([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
+
+ // function soundio_device_equal - soundio.h (890, 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 (895, 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 (899, 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 (904, 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 (909, 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 (914, 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 (924, 41)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_outstream_create([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
+
+ // function soundio_outstream_destroy - soundio.h (926, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_outstream_destroy([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
+
+ // function soundio_outstream_open - soundio.h (950, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_outstream_open([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
+
+ // function soundio_outstream_start - soundio.h (961, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_outstream_start([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
+
+ // function soundio_outstream_begin_write - soundio.h (993, 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 (1005, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_outstream_end_write([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
+
+ // function soundio_outstream_clear_buffer - soundio.h (1020, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_outstream_clear_buffer([CTypeDetails("Pointer<SoundIoOutStream>")]System.IntPtr @outstream);
+
+ // function soundio_outstream_pause - soundio.h (1041, 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 (1054, 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_instream_create - soundio.h (1064, 40)
+ [DllImport(LibraryName)]
+ internal static extern System.IntPtr soundio_instream_create([CTypeDetails("Pointer<SoundIoDevice>")]System.IntPtr @device);
+
+ // function soundio_instream_destroy - soundio.h (1066, 21)
+ [DllImport(LibraryName)]
+ internal static extern void soundio_instream_destroy([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
+
+ // function soundio_instream_open - soundio.h (1086, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_instream_open([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
+
+ // function soundio_instream_start - soundio.h (1095, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_instream_start([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
+
+ // function soundio_instream_begin_read - soundio.h (1126, 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 (1136, 20)
+ [DllImport(LibraryName)]
+ internal static extern int soundio_instream_end_read([CTypeDetails("Pointer<SoundIoInStream>")]System.IntPtr @instream);
+
+ // function soundio_instream_pause - soundio.h (1149, 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 (1159, 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 (1173, 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 (1174, 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 (1178, 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 (1181, 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 (1183, 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 (1186, 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 (1188, 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 (1191, 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 (1194, 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 (1197, 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; }
+ }
+
+}
diff --git a/Ryujinx.Audio/PlaybackState.cs b/Ryujinx.Audio/PlaybackState.cs
index 8b53128aaf..7d8620924b 100644
--- a/Ryujinx.Audio/PlaybackState.cs
+++ b/Ryujinx.Audio/PlaybackState.cs
@@ -1,8 +1,17 @@
namespace Ryujinx.Audio
{
+ /// <summary>
+ /// The playback state of a track
+ /// </summary>
public enum PlaybackState
{
+ /// <summary>
+ /// The track is currently playing
+ /// </summary>
Playing = 0,
+ /// <summary>
+ /// The track is currently stopped
+ /// </summary>
Stopped = 1
}
}
\ No newline at end of file
diff --git a/Ryujinx.Audio/Renderers/DummyAudioOut.cs b/Ryujinx.Audio/Renderers/DummyAudioOut.cs
new file mode 100644
index 0000000000..659734b6dc
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/DummyAudioOut.cs
@@ -0,0 +1,63 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Ryujinx.Audio
+{
+ /// <summary>
+ /// A Dummy audio renderer that does not output any audio
+ /// </summary>
+ public class DummyAudioOut : IAalOutput
+ {
+ private ConcurrentQueue<long> m_Buffers;
+
+ public DummyAudioOut()
+ {
+ m_Buffers = new ConcurrentQueue<long>();
+ }
+
+ /// <summary>
+ /// Dummy audio output is always available, Baka!
+ /// </summary>
+ public static bool IsSupported => true;
+
+ public PlaybackState GetState(int trackId) => PlaybackState.Stopped;
+
+ public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback) => 1;
+
+ public void CloseTrack(int trackId) { }
+
+ public void Start(int trackId) { }
+
+ public void Stop(int trackId) { }
+
+ public void AppendBuffer<T>(int trackID, long bufferTag, T[] buffer)
+ where T : struct
+ {
+ m_Buffers.Enqueue(bufferTag);
+ }
+
+ public long[] GetReleasedBuffers(int trackId, int maxCount)
+ {
+ List<long> bufferTags = new List<long>();
+
+ for (int i = 0; i < maxCount; i++)
+ {
+ if (!m_Buffers.TryDequeue(out long tag))
+ {
+ break;
+ }
+
+ bufferTags.Add(tag);
+ }
+
+ return bufferTags.ToArray();
+ }
+
+ public bool ContainsBuffer(int trackID, long bufferTag) => false;
+
+ public void Dispose()
+ {
+ m_Buffers.Clear();
+ }
+ }
+}
diff --git a/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
similarity index 94%
rename from Ryujinx.Audio/OpenAL/OpenALAudioOut.cs
rename to Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
index 9a75c5685e..93f9287910 100644
--- a/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs
+++ b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
@@ -6,8 +6,11 @@ using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
-namespace Ryujinx.Audio.OpenAL
+namespace Ryujinx.Audio
{
+ /// <summary>
+ /// An audio renderer that uses OpenAL as the audio backend
+ /// </summary>
public class OpenALAudioOut : IAalOutput, IDisposable
{
private const int MaxTracks = 256;
@@ -176,6 +179,24 @@ namespace Ryujinx.Audio.OpenAL
AudioPollerThread.Start();
}
+ /// <summary>
+ /// True if OpenAL is supported on the device.
+ /// </summary>
+ public static bool IsSupported
+ {
+ get
+ {
+ try
+ {
+ return AudioContext.AvailableDevices.Count > 0;
+ }
+ catch
+ {
+ return false;
+ }
+ }
+ }
+
private void AudioPollerWork()
{
do
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
new file mode 100644
index 0000000000..76b1290d1b
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
@@ -0,0 +1,189 @@
+using Ryujinx.Audio.SoundIo;
+using SoundIOSharp;
+using System.Collections.Generic;
+
+namespace Ryujinx.Audio
+{
+ /// <summary>
+ /// An audio renderer that uses libsoundio as the audio backend
+ /// </summary>
+ public class SoundIoAudioOut : IAalOutput
+ {
+ /// <summary>
+ /// The maximum amount of tracks we can issue simultaneously
+ /// </summary>
+ private const int MaximumTracks = 256;
+
+ /// <summary>
+ /// The <see cref="SoundIO"/> audio context
+ /// </summary>
+ private SoundIO m_AudioContext;
+
+ /// <summary>
+ /// The <see cref="SoundIODevice"/> audio device
+ /// </summary>
+ private SoundIODevice m_AudioDevice;
+
+ /// <summary>
+ /// An object pool containing <see cref="SoundIoAudioTrack"/> objects
+ /// </summary>
+ private SoundIoAudioTrackPool m_TrackPool;
+
+ /// <summary>
+ /// True if SoundIO is supported on the device.
+ /// </summary>
+ public static bool IsSupported => true;
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoAudioOut"/>
+ /// </summary>
+ public SoundIoAudioOut()
+ {
+ m_AudioContext = new SoundIO();
+
+ m_AudioContext.Connect();
+ m_AudioContext.FlushEvents();
+
+ m_AudioDevice = m_AudioContext.GetOutputDevice(m_AudioContext.DefaultOutputDeviceIndex);
+ m_TrackPool = new SoundIoAudioTrackPool(m_AudioContext, m_AudioDevice, MaximumTracks);
+ }
+
+ /// <summary>
+ /// Gets the current playback state of the specified track
+ /// </summary>
+ /// <param name="trackId">The track to retrieve the playback state for</param>
+ public PlaybackState GetState(int trackId)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ return track.State;
+ }
+
+ return PlaybackState.Stopped;
+ }
+
+ /// <summary>
+ /// Creates a new audio track with the specified parameters
+ /// </summary>
+ /// <param name="sampleRate">The requested sample rate</param>
+ /// <param name="channels">The requested channels</param>
+ /// <param name="callback">A <see cref="ReleaseCallback" /> that represents the delegate to invoke when a buffer has been released by the audio track</param>
+ /// <returns>The created track's Track ID</returns>
+ public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
+ {
+ if (!m_TrackPool.TryGet(out SoundIoAudioTrack track))
+ {
+ return -1;
+ }
+
+ // Open the output. We currently only support 16-bit signed LE
+ track.Open(sampleRate, channels, callback, SoundIOFormat.S16LE);
+
+ return track.TrackID;
+ }
+
+ /// <summary>
+ /// Stops playback and closes the track specified by <paramref name="trackId"/>
+ /// </summary>
+ /// <param name="trackId">The ID of the track to close</param>
+ public void CloseTrack(int trackId)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ // Close and dispose of the track
+ track.Close();
+
+ // Recycle the track back into the pool
+ m_TrackPool.Put(track);
+ }
+ }
+
+ /// <summary>
+ /// Starts playback
+ /// </summary>
+ /// <param name="trackId">The ID of the track to start playback on</param>
+ public void Start(int trackId)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ track.Start();
+ }
+ }
+
+ /// <summary>
+ /// Stops playback
+ /// </summary>
+ /// <param name="trackId">The ID of the track to stop playback on</param>
+ public void Stop(int trackId)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ track.Stop();
+ }
+ }
+
+ /// <summary>
+ /// Appends an audio buffer to the specified track
+ /// </summary>
+ /// <typeparam name="T">The sample type of the buffer</typeparam>
+ /// <param name="trackId">The track to append the buffer to</param>
+ /// <param name="bufferTag">The internal tag of the buffer</param>
+ /// <param name="buffer">The buffer to append to the track</param>
+ public void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer)
+ where T : struct
+ {
+ if(m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ track.AppendBuffer(bufferTag, buffer);
+ }
+ }
+
+ /// <summary>
+ /// Returns a value indicating whether the specified buffer is currently reserved by the specified track
+ /// </summary>
+ /// <param name="trackId">The track to check</param>
+ /// <param name="bufferTag">The buffer tag to check</param>
+ public bool ContainsBuffer(int trackId, long bufferTag)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ return track.ContainsBuffer(bufferTag);
+ }
+
+ return false;
+ }
+
+ /// <summary>
+ /// Gets a list of buffer tags the specified track is no longer reserving
+ /// </summary>
+ /// <param name="trackId">The track to retrieve buffer tags from</param>
+ /// <param name="maxCount">The maximum amount of buffer tags to retrieve</param>
+ /// <returns>Buffers released by the specified track</returns>
+ public long[] GetReleasedBuffers(int trackId, int maxCount)
+ {
+ if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ List<long> bufferTags = new List<long>();
+
+ while(maxCount-- > 0 && track.ReleasedBuffers.TryDequeue(out long tag))
+ {
+ bufferTags.Add(tag);
+ }
+
+ return bufferTags.ToArray();
+ }
+
+ return new long[0];
+ }
+
+ /// <summary>
+ /// Releases the unmanaged resources used by the <see cref="SoundIoAudioOut" />
+ /// </summary>
+ public void Dispose()
+ {
+ m_TrackPool.Dispose();
+ m_AudioContext.Disconnect();
+ m_AudioContext.Dispose();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrack.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrack.cs
new file mode 100644
index 0000000000..97ba11d513
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrack.cs
@@ -0,0 +1,560 @@
+using SoundIOSharp;
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.Audio.SoundIo
+{
+ internal class SoundIoAudioTrack : IDisposable
+ {
+ /// <summary>
+ /// The audio track ring buffer
+ /// </summary>
+ private SoundIoRingBuffer m_Buffer;
+
+ /// <summary>
+ /// A list of buffers currently pending writeback to the audio backend
+ /// </summary>
+ private ConcurrentQueue<SoundIoBuffer> m_ReservedBuffers;
+
+ /// <summary>
+ /// Occurs when a buffer has been released by the audio backend
+ /// </summary>
+ private event ReleaseCallback BufferReleased;
+
+ /// <summary>
+ /// The track ID of this <see cref="SoundIoAudioTrack"/>
+ /// </summary>
+ public int TrackID { get; private set; }
+
+ /// <summary>
+ /// The current playback state
+ /// </summary>
+ public PlaybackState State { get; private set; }
+
+ /// <summary>
+ /// The <see cref="SoundIO"/> audio context this track belongs to
+ /// </summary>
+ public SoundIO AudioContext { get; private set; }
+
+ /// <summary>
+ /// The <see cref="SoundIODevice"/> this track belongs to
+ /// </summary>
+ public SoundIODevice AudioDevice { get; private set; }
+
+ /// <summary>
+ /// The audio output stream of this track
+ /// </summary>
+ public SoundIOOutStream AudioStream { get; private set; }
+
+ /// <summary>
+ /// Released buffers the track is no longer holding
+ /// </summary>
+ public ConcurrentQueue<long> ReleasedBuffers { get; private set; }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoAudioTrack"/>
+ /// </summary>
+ /// <param name="trackId">The track ID</param>
+ /// <param name="audioContext">The SoundIO audio context</param>
+ /// <param name="audioDevice">The SoundIO audio device</param>
+ public SoundIoAudioTrack(int trackId, SoundIO audioContext, SoundIODevice audioDevice)
+ {
+ TrackID = trackId;
+ AudioContext = audioContext;
+ AudioDevice = audioDevice;
+ State = PlaybackState.Stopped;
+ ReleasedBuffers = new ConcurrentQueue<long>();
+
+ m_Buffer = new SoundIoRingBuffer();
+ m_ReservedBuffers = new ConcurrentQueue<SoundIoBuffer>();
+ }
+
+ /// <summary>
+ /// Opens the audio track with the specified parameters
+ /// </summary>
+ /// <param name="sampleRate">The requested sample rate of the track</param>
+ /// <param name="channelCount">The requested channel count of the track</param>
+ /// <param name="callback">A <see cref="ReleaseCallback" /> that represents the delegate to invoke when a buffer has been released by the audio track</param>
+ /// <param name="format">The requested sample format of the track</param>
+ public void Open(
+ int sampleRate,
+ int channelCount,
+ ReleaseCallback callback,
+ SoundIOFormat format = SoundIOFormat.S16LE)
+ {
+ // Close any existing audio streams
+ if (AudioStream != null)
+ {
+ Close();
+ }
+
+ if (!AudioDevice.SupportsSampleRate(sampleRate))
+ {
+ throw new InvalidOperationException($"This sound device does not support a sample rate of {sampleRate}Hz");
+ }
+
+ if (!AudioDevice.SupportsFormat(format))
+ {
+ throw new InvalidOperationException($"This sound device does not support SoundIOFormat.{Enum.GetName(typeof(SoundIOFormat), format)}");
+ }
+
+ AudioStream = AudioDevice.CreateOutStream();
+
+ AudioStream.Name = $"SwitchAudioTrack_{TrackID}";
+ AudioStream.Layout = SoundIOChannelLayout.GetDefault(channelCount);
+ AudioStream.Format = format;
+ AudioStream.SampleRate = sampleRate;
+
+ AudioStream.WriteCallback = WriteCallback;
+
+ BufferReleased += callback;
+
+ AudioStream.Open();
+ }
+
+ /// <summary>
+ /// This callback occurs when the sound device is ready to buffer more frames
+ /// </summary>
+ /// <param name="minFrameCount">The minimum amount of frames expected by the audio backend</param>
+ /// <param name="maxFrameCount">The maximum amount of frames that can be written to the audio backend</param>
+ private unsafe void WriteCallback(int minFrameCount, int maxFrameCount)
+ {
+ int bytesPerFrame = AudioStream.BytesPerFrame;
+ uint bytesPerSample = (uint)AudioStream.BytesPerSample;
+
+ int bufferedFrames = m_Buffer.Length / bytesPerFrame;
+ long bufferedSamples = m_Buffer.Length / bytesPerSample;
+
+ int frameCount = Math.Min(bufferedFrames, maxFrameCount);
+
+ if (frameCount == 0)
+ {
+ return;
+ }
+
+ SoundIOChannelAreas areas = AudioStream.BeginWrite(ref frameCount);
+ int channelCount = areas.ChannelCount;
+
+ byte[] samples = new byte[frameCount * bytesPerFrame];
+
+ m_Buffer.Read(samples, 0, samples.Length);
+
+ // 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.
+
+ // Mono
+ if (channelCount == 1)
+ {
+ SoundIOChannelArea area = areas.GetArea(0);
+
+ fixed (byte* srcptr = samples)
+ {
+ if (bytesPerSample == 1)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ ((byte*)area.Pointer)[0] = srcptr[frame * bytesPerFrame];
+
+ area.Pointer += area.Step;
+ }
+ }
+ else if (bytesPerSample == 2)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ ((short*)area.Pointer)[0] = ((short*)srcptr)[frame * bytesPerFrame >> 1];
+
+ area.Pointer += area.Step;
+ }
+ }
+ else if (bytesPerSample == 4)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ ((int*)area.Pointer)[0] = ((int*)srcptr)[frame * bytesPerFrame >> 2];
+
+ area.Pointer += area.Step;
+ }
+ }
+ else
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ Unsafe.CopyBlockUnaligned((byte*)area.Pointer, srcptr + (frame * bytesPerFrame), bytesPerSample);
+
+ area.Pointer += area.Step;
+ }
+ }
+ }
+ }
+ // Stereo
+ else if (channelCount == 2)
+ {
+ SoundIOChannelArea area1 = areas.GetArea(0);
+ SoundIOChannelArea area2 = areas.GetArea(1);
+
+ fixed (byte* srcptr = samples)
+ {
+ if (bytesPerSample == 1)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((byte*)area1.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 0];
+
+ // Channel 2
+ ((byte*)area2.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 1];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ }
+ }
+ else if (bytesPerSample == 2)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((short*)area1.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 0];
+
+ // Channel 2
+ ((short*)area2.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 1];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ }
+ }
+ else if (bytesPerSample == 4)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((int*)area1.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 0];
+
+ // Channel 2
+ ((int*)area2.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 1];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ }
+ }
+ else
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ Unsafe.CopyBlockUnaligned((byte*)area1.Pointer, srcptr + (frame * bytesPerFrame) + (0 * bytesPerSample), bytesPerSample);
+
+ // Channel 2
+ Unsafe.CopyBlockUnaligned((byte*)area2.Pointer, srcptr + (frame * bytesPerFrame) + (1 * bytesPerSample), bytesPerSample);
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ }
+ }
+ }
+ }
+ // 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);
+
+ fixed (byte* srcptr = samples)
+ {
+ if (bytesPerSample == 1)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((byte*)area1.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 0];
+
+ // Channel 2
+ ((byte*)area2.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 1];
+
+ // Channel 3
+ ((byte*)area3.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 2];
+
+ // Channel 4
+ ((byte*)area4.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 3];
+
+ // Channel 5
+ ((byte*)area5.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 4];
+
+ // Channel 6
+ ((byte*)area6.Pointer)[0] = srcptr[(frame * bytesPerFrame) + 5];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ area3.Pointer += area3.Step;
+ area4.Pointer += area4.Step;
+ area5.Pointer += area5.Step;
+ area6.Pointer += area6.Step;
+ }
+ }
+ else if (bytesPerSample == 2)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((short*)area1.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 0];
+
+ // Channel 2
+ ((short*)area2.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 1];
+
+ // Channel 3
+ ((short*)area3.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 2];
+
+ // Channel 4
+ ((short*)area4.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 3];
+
+ // Channel 5
+ ((short*)area5.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 4];
+
+ // Channel 6
+ ((short*)area6.Pointer)[0] = ((short*)srcptr)[(frame * bytesPerFrame >> 1) + 5];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ area3.Pointer += area3.Step;
+ area4.Pointer += area4.Step;
+ area5.Pointer += area5.Step;
+ area6.Pointer += area6.Step;
+ }
+ }
+ else if (bytesPerSample == 4)
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ ((int*)area1.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 0];
+
+ // Channel 2
+ ((int*)area2.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 1];
+
+ // Channel 3
+ ((int*)area3.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 2];
+
+ // Channel 4
+ ((int*)area4.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 3];
+
+ // Channel 5
+ ((int*)area5.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 4];
+
+ // Channel 6
+ ((int*)area6.Pointer)[0] = ((int*)srcptr)[(frame * bytesPerFrame >> 2) + 5];
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ area3.Pointer += area3.Step;
+ area4.Pointer += area4.Step;
+ area5.Pointer += area5.Step;
+ area6.Pointer += area6.Step;
+ }
+ }
+ else
+ {
+ for (int frame = 0; frame < frameCount; frame++)
+ {
+ // Channel 1
+ Unsafe.CopyBlockUnaligned((byte*)area1.Pointer, srcptr + (frame * bytesPerFrame) + (0 * bytesPerSample), bytesPerSample);
+
+ // Channel 2
+ Unsafe.CopyBlockUnaligned((byte*)area2.Pointer, srcptr + (frame * bytesPerFrame) + (1 * bytesPerSample), bytesPerSample);
+
+ // Channel 3
+ Unsafe.CopyBlockUnaligned((byte*)area3.Pointer, srcptr + (frame * bytesPerFrame) + (2 * bytesPerSample), bytesPerSample);
+
+ // Channel 4
+ Unsafe.CopyBlockUnaligned((byte*)area4.Pointer, srcptr + (frame * bytesPerFrame) + (3 * bytesPerSample), bytesPerSample);
+
+ // Channel 5
+ Unsafe.CopyBlockUnaligned((byte*)area5.Pointer, srcptr + (frame * bytesPerFrame) + (4 * bytesPerSample), bytesPerSample);
+
+ // Channel 6
+ Unsafe.CopyBlockUnaligned((byte*)area6.Pointer, srcptr + (frame * bytesPerFrame) + (5 * bytesPerSample), bytesPerSample);
+
+ area1.Pointer += area1.Step;
+ area2.Pointer += area2.Step;
+ area3.Pointer += area3.Step;
+ area4.Pointer += area4.Step;
+ area5.Pointer += area5.Step;
+ area6.Pointer += area6.Step;
+ }
+ }
+ }
+ }
+ // 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++)
+ {
+ // Copy channel by channel, frame by frame. This is slow!
+ Unsafe.CopyBlockUnaligned((byte*)channels[channel].Pointer, srcptr + (frame * bytesPerFrame) + (channel * bytesPerSample), bytesPerSample);
+
+ channels[channel].Pointer += channels[channel].Step;
+ }
+ }
+ }
+
+ AudioStream.EndWrite();
+
+ UpdateReleasedBuffers(samples.Length);
+ }
+
+ /// <summary>
+ /// Releases any buffers that have been fully written to the output device
+ /// </summary>
+ /// <param name="bytesRead">The amount of bytes written in the last device write</param>
+ private void UpdateReleasedBuffers(int bytesRead)
+ {
+ bool bufferReleased = false;
+
+ while (bytesRead > 0)
+ {
+ if (m_ReservedBuffers.TryPeek(out SoundIoBuffer buffer))
+ {
+ if (buffer.Length > bytesRead)
+ {
+ buffer.Length -= bytesRead;
+ bytesRead = 0;
+ }
+ else
+ {
+ bufferReleased = true;
+ bytesRead -= buffer.Length;
+
+ m_ReservedBuffers.TryDequeue(out buffer);
+ ReleasedBuffers.Enqueue(buffer.Tag);
+ }
+ }
+ }
+
+ if (bufferReleased)
+ {
+ OnBufferReleased();
+ }
+ }
+
+ /// <summary>
+ /// Starts audio playback
+ /// </summary>
+ public void Start()
+ {
+ if (AudioStream == null)
+ {
+ return;
+ }
+
+ AudioStream.Start();
+ AudioStream.Pause(false);
+ AudioContext.FlushEvents();
+ State = PlaybackState.Playing;
+ }
+
+ /// <summary>
+ /// Stops audio playback
+ /// </summary>
+ public void Stop()
+ {
+ if (AudioStream == null)
+ {
+ return;
+ }
+
+ AudioStream.Pause(true);
+ AudioContext.FlushEvents();
+ State = PlaybackState.Stopped;
+ }
+
+ /// <summary>
+ /// Appends an audio buffer to the tracks internal ring buffer
+ /// </summary>
+ /// <typeparam name="T">The audio sample type</typeparam>
+ /// <param name="bufferTag">The unqiue tag of the buffer being appended</param>
+ /// <param name="buffer">The buffer to append</param>
+ public void AppendBuffer<T>(long bufferTag, T[] buffer)
+ {
+ if (AudioStream == null)
+ {
+ return;
+ }
+
+ // Calculate the size of the audio samples
+ int size = Unsafe.SizeOf<T>();
+
+ // Calculate the amount of bytes to copy from the buffer
+ int bytesToCopy = size * buffer.Length;
+
+ // Copy the memory to our ring buffer
+ m_Buffer.Write(buffer, 0, bytesToCopy);
+
+ // Keep track of "buffered" buffers
+ m_ReservedBuffers.Enqueue(new SoundIoBuffer(bufferTag, bytesToCopy));
+ }
+
+ /// <summary>
+ /// Returns a value indicating whether the specified buffer is currently reserved by the track
+ /// </summary>
+ /// <param name="bufferTag">The buffer tag to check</param>
+ public bool ContainsBuffer(long bufferTag)
+ {
+ return m_ReservedBuffers.Any(x => x.Tag == bufferTag);
+ }
+
+ /// <summary>
+ /// Closes the <see cref="SoundIoAudioTrack"/>
+ /// </summary>
+ public void Close()
+ {
+ if (AudioStream != null)
+ {
+ AudioStream.Pause(true);
+ AudioStream.Dispose();
+ }
+
+ m_Buffer.Clear();
+ OnBufferReleased();
+ ReleasedBuffers.Clear();
+
+ State = PlaybackState.Stopped;
+ AudioStream = null;
+ BufferReleased = null;
+ }
+
+ private void OnBufferReleased()
+ {
+ BufferReleased?.Invoke();
+ }
+
+ /// <summary>
+ /// Releases the unmanaged resources used by the <see cref="SoundIoAudioTrack" />
+ /// </summary>
+ public void Dispose()
+ {
+ Close();
+ }
+
+ ~SoundIoAudioTrack()
+ {
+ Dispose();
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrackPool.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrackPool.cs
new file mode 100644
index 0000000000..ec256e2086
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioTrackPool.cs
@@ -0,0 +1,193 @@
+using SoundIOSharp;
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+
+namespace Ryujinx.Audio.SoundIo
+{
+ /// <summary>
+ /// An object pool containing a set of audio tracks
+ /// </summary>
+ internal class SoundIoAudioTrackPool : IDisposable
+ {
+ /// <summary>
+ /// The current size of the <see cref="SoundIoAudioTrackPool"/>
+ /// </summary>
+ private int m_Size;
+
+ /// <summary>
+ /// The maximum size of the <see cref="SoundIoAudioTrackPool"/>
+ /// </summary>
+ private int m_MaxSize;
+
+ /// <summary>
+ /// The <see cref="SoundIO"/> audio context this track pool belongs to
+ /// </summary>
+ private SoundIO m_Context;
+
+ /// <summary>
+ /// The <see cref="SoundIODevice"/> audio device this track pool belongs to
+ /// </summary>
+ private SoundIODevice m_Device;
+
+ /// <summary>
+ /// The queue that keeps track of the available <see cref="SoundIoAudioTrack"/> in the pool.
+ /// </summary>
+ private ConcurrentQueue<SoundIoAudioTrack> m_Queue;
+
+ /// <summary>
+ /// The dictionary providing mapping between a TrackID and <see cref="SoundIoAudioTrack"/>
+ /// </summary>
+ private ConcurrentDictionary<int, SoundIoAudioTrack> m_TrackList;
+
+ /// <summary>
+ /// Gets the current size of the <see cref="SoundIoAudioTrackPool"/>
+ /// </summary>
+ public int Size { get => m_Size; }
+
+ /// <summary>
+ /// Gets the maximum size of the <see cref="SoundIoAudioTrackPool"/>
+ /// </summary>
+ public int MaxSize { get => m_MaxSize; }
+
+ /// <summary>
+ /// Gets a value that indicates whether the <see cref="SoundIoAudioTrackPool"/> is empty
+ /// </summary>
+ public bool IsEmpty { get => m_Queue.IsEmpty; }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoAudioTrackPool"/> that is empty
+ /// </summary>
+ /// <param name="maxSize">The maximum amount of tracks that can be created</param>
+ public SoundIoAudioTrackPool(SoundIO context, SoundIODevice device, int maxSize)
+ {
+ m_Size = 0;
+ m_Context = context;
+ m_Device = device;
+ m_MaxSize = maxSize;
+
+ m_Queue = new ConcurrentQueue<SoundIoAudioTrack>();
+ m_TrackList = new ConcurrentDictionary<int, SoundIoAudioTrack>();
+ }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoAudioTrackPool"/> that contains
+ /// the specified amount of <see cref="SoundIoAudioTrack"/>
+ /// </summary>
+ /// <param name="maxSize">The maximum amount of tracks that can be created</param>
+ /// <param name="initialCapacity">The initial number of tracks that the pool contains</param>
+ public SoundIoAudioTrackPool(SoundIO context, SoundIODevice device, int maxSize, int initialCapacity)
+ : this(context, device, maxSize)
+ {
+ var trackCollection = Enumerable.Range(0, initialCapacity)
+ .Select(TrackFactory);
+
+ m_Size = initialCapacity;
+ m_Queue = new ConcurrentQueue<SoundIoAudioTrack>(trackCollection);
+ }
+
+ /// <summary>
+ /// Creates a new <see cref="SoundIoAudioTrack"/> with the proper AudioContext and AudioDevice
+ /// and the specified <paramref name="trackId" />
+ /// </summary>
+ /// <param name="trackId">The ID of the track to be created</param>
+ /// <returns>A new AudioTrack with the specified ID</returns>
+ private SoundIoAudioTrack TrackFactory(int trackId)
+ {
+ // Create a new AudioTrack
+ SoundIoAudioTrack track = new SoundIoAudioTrack(trackId, m_Context, m_Device);
+
+ // Keep track of issued tracks
+ m_TrackList[trackId] = track;
+
+ return track;
+ }
+
+ /// <summary>
+ /// Retrieves a <see cref="SoundIoAudioTrack"/> from the pool
+ /// </summary>
+ /// <returns>An AudioTrack from the pool</returns>
+ public SoundIoAudioTrack Get()
+ {
+ // If we have a track available, reuse it
+ if (m_Queue.TryDequeue(out SoundIoAudioTrack track))
+ {
+ return track;
+ }
+
+ // Have we reached the maximum size of our pool?
+ if (m_Size >= m_MaxSize)
+ {
+ return null;
+ }
+
+ // We don't have any pooled tracks, so create a new one
+ return TrackFactory(m_Size++);
+ }
+
+ /// <summary>
+ /// Retrieves the <see cref="SoundIoAudioTrack"/> associated with the specified <paramref name="trackId"/> from the pool
+ /// </summary>
+ /// <param name="trackId">The ID of the track to retrieve</param>
+ public SoundIoAudioTrack Get(int trackId)
+ {
+ if (m_TrackList.TryGetValue(trackId, out SoundIoAudioTrack track))
+ {
+ return track;
+ }
+
+ return null;
+ }
+
+ /// <summary>
+ /// Attempers to get a <see cref="SoundIoAudioTrack"/> from the pool
+ /// </summary>
+ /// <param name="track">The track retrieved from the pool</param>
+ /// <returns>True if retrieve was successful</returns>
+ public bool TryGet(out SoundIoAudioTrack track)
+ {
+ track = Get();
+
+ return track != null;
+ }
+
+ /// <summary>
+ /// Attempts to get the <see cref="SoundIoAudioTrack" /> associated with the specified <paramref name="trackId"/> from the pool
+ /// </summary>
+ /// <param name="trackId">The ID of the track to retrieve</param>
+ /// <param name="track">The track retrieved from the pool</param>
+ public bool TryGet(int trackId, out SoundIoAudioTrack track)
+ {
+ return m_TrackList.TryGetValue(trackId, out track);
+ }
+
+ /// <summary>
+ /// Returns an <see cref="SoundIoAudioTrack"/> back to the pool for reuse
+ /// </summary>
+ /// <param name="track">The track to be returned to the pool</param>
+ public void Put(SoundIoAudioTrack track)
+ {
+ // Ensure the track is disposed and not playing audio
+ track.Close();
+
+ // Requeue the track for reuse later
+ m_Queue.Enqueue(track);
+ }
+
+ /// <summary>
+ /// Releases the unmanaged resources used by the <see cref="SoundIoAudioTrackPool" />
+ /// </summary>
+ public void Dispose()
+ {
+ foreach (var track in m_TrackList)
+ {
+ track.Value.Close();
+ track.Value.Dispose();
+ }
+
+ m_Size = 0;
+ m_Queue.Clear();
+ m_TrackList.Clear();
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoBuffer.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoBuffer.cs
new file mode 100644
index 0000000000..2a6190b53b
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoBuffer.cs
@@ -0,0 +1,29 @@
+namespace Ryujinx.Audio.SoundIo
+{
+ /// <summary>
+ /// Represents the remaining bytes left buffered for a specific buffer tag
+ /// </summary>
+ internal class SoundIoBuffer
+ {
+ /// <summary>
+ /// The buffer tag this <see cref="SoundIoBuffer"/> represents
+ /// </summary>
+ public long Tag { get; private set; }
+
+ /// <summary>
+ /// The remaining bytes still to be released
+ /// </summary>
+ public int Length { get; set; }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoBuffer"/>
+ /// </summary>
+ /// <param name="tag">The buffer tag</param>
+ /// <param name="length">The size of the buffer</param>
+ public SoundIoBuffer(long tag, int length)
+ {
+ Tag = tag;
+ Length = length;
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoRingBuffer.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoRingBuffer.cs
new file mode 100644
index 0000000000..b288502132
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoRingBuffer.cs
@@ -0,0 +1,204 @@
+using System;
+
+namespace Ryujinx.Audio.SoundIo
+{
+ /// <summary>
+ /// A thread-safe variable-size circular buffer
+ /// </summary>
+ internal class SoundIoRingBuffer
+ {
+ private byte[] m_Buffer;
+ private int m_Size;
+ private int m_HeadOffset;
+ private int m_TailOffset;
+
+ /// <summary>
+ /// Gets the available bytes in the ring buffer
+ /// </summary>
+ public int Length
+ {
+ get { return m_Size; }
+ }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoRingBuffer"/>
+ /// </summary>
+ public SoundIoRingBuffer()
+ {
+ m_Buffer = new byte[2048];
+ }
+
+ /// <summary>
+ /// Constructs a new instance of a <see cref="SoundIoRingBuffer"/> with the specified capacity
+ /// </summary>
+ /// <param name="capacity">The number of entries that the <see cref="SoundIoRingBuffer"/> can initially contain</param>
+ public SoundIoRingBuffer(int capacity)
+ {
+ m_Buffer = new byte[capacity];
+ }
+
+ /// <summary>
+ /// Clears the ring buffer
+ /// </summary>
+ public void Clear()
+ {
+ m_Size = 0;
+ m_HeadOffset = 0;
+ m_TailOffset = 0;
+ }
+
+ /// <summary>
+ /// Clears the specified amount of bytes from the ring buffer
+ /// </summary>
+ /// <param name="size">The amount of bytes to clear from the ring buffer</param>
+ public void Clear(int size)
+ {
+ lock (this)
+ {
+ if (size > m_Size)
+ {
+ size = m_Size;
+ }
+
+ if (size == 0)
+ {
+ return;
+ }
+
+ m_HeadOffset = (m_HeadOffset + size) % m_Buffer.Length;
+ m_Size -= size;
+
+ if (m_Size == 0)
+ {
+ m_HeadOffset = 0;
+ m_TailOffset = 0;
+ }
+
+ return;
+ }
+ }
+
+ /// <summary>
+ /// Extends the capacity of the ring buffer
+ /// </summary>
+ private void SetCapacity(int capacity)
+ {
+ byte[] buffer = new byte[capacity];
+
+ if (m_Size > 0)
+ {
+ if (m_HeadOffset < m_TailOffset)
+ {
+ Buffer.BlockCopy(m_Buffer, m_HeadOffset, buffer, 0, m_Size);
+ }
+ else
+ {
+ Buffer.BlockCopy(m_Buffer, m_HeadOffset, buffer, 0, m_Buffer.Length - m_HeadOffset);
+ Buffer.BlockCopy(m_Buffer, 0, buffer, m_Buffer.Length - m_HeadOffset, m_TailOffset);
+ }
+ }
+
+ m_Buffer = buffer;
+ m_HeadOffset = 0;
+ m_TailOffset = m_Size;
+ }
+
+
+ /// <summary>
+ /// Writes a sequence of bytes to the ring buffer
+ /// </summary>
+ /// <param name="buffer">A byte array containing the data to write</param>
+ /// <param name="index">The zero-based byte offset in <paramref name="buffer" /> from which to begin copying bytes to the ring buffer</param>
+ /// <param name="count">The number of bytes to write</param>
+ public void Write<T>(T[] buffer, int index, int count)
+ {
+ if (count == 0)
+ {
+ return;
+ }
+
+ lock (this)
+ {
+ if ((m_Size + count) > m_Buffer.Length)
+ {
+ SetCapacity((m_Size + count + 2047) & ~2047);
+ }
+
+ if (m_HeadOffset < m_TailOffset)
+ {
+ int tailLength = m_Buffer.Length - m_TailOffset;
+
+ if (tailLength >= count)
+ {
+ Buffer.BlockCopy(buffer, index, m_Buffer, m_TailOffset, count);
+ }
+ else
+ {
+ Buffer.BlockCopy(buffer, index, m_Buffer, m_TailOffset, tailLength);
+ Buffer.BlockCopy(buffer, index + tailLength, m_Buffer, 0, count - tailLength);
+ }
+ }
+ else
+ {
+ Buffer.BlockCopy(buffer, index, m_Buffer, m_TailOffset, count);
+ }
+
+ m_Size += count;
+ m_TailOffset = (m_TailOffset + count) % m_Buffer.Length;
+ }
+ }
+
+ /// <summary>
+ /// Reads a sequence of bytes from the ring buffer and advances the position within the ring buffer by the number of bytes read
+ /// </summary>
+ /// <param name="buffer">The buffer to write the data into</param>
+ /// <param name="index">The zero-based byte offset in <paramref name="buffer" /> at which the read bytes will be placed</param>
+ /// <param name="count">The maximum number of bytes to read</param>
+ /// <returns>The total number of bytes read into the buffer. This might be less than the number of bytes requested if that number of bytes are not currently available, or zero if the ring buffer is empty</returns>
+ public int Read<T>(T[] buffer, int index, int count)
+ {
+ lock (this)
+ {
+ if (count > m_Size)
+ {
+ count = m_Size;
+ }
+
+ if (count == 0)
+ {
+ return 0;
+ }
+
+ if (m_HeadOffset < m_TailOffset)
+ {
+ Buffer.BlockCopy(m_Buffer, m_HeadOffset, buffer, index, count);
+ }
+ else
+ {
+ int tailLength = m_Buffer.Length - m_HeadOffset;
+
+ if (tailLength >= count)
+ {
+ Buffer.BlockCopy(m_Buffer, m_HeadOffset, buffer, index, count);
+ }
+ else
+ {
+ Buffer.BlockCopy(m_Buffer, m_HeadOffset, buffer, index, tailLength);
+ Buffer.BlockCopy(m_Buffer, 0, buffer, index + tailLength, count - tailLength);
+ }
+ }
+
+ m_Size -= count;
+ m_HeadOffset = (m_HeadOffset + count) % m_Buffer.Length;
+
+ if (m_Size == 0)
+ {
+ m_HeadOffset = 0;
+ m_TailOffset = 0;
+ }
+
+ return count;
+ }
+ }
+ }
+}
diff --git a/Ryujinx.Audio/Ryujinx.Audio.csproj b/Ryujinx.Audio/Ryujinx.Audio.csproj
index 3fc6117096..82d2a4d152 100644
--- a/Ryujinx.Audio/Ryujinx.Audio.csproj
+++ b/Ryujinx.Audio/Ryujinx.Audio.csproj
@@ -5,12 +5,36 @@
<RuntimeIdentifiers>win10-x64;osx-x64;linux-x64</RuntimeIdentifiers>
</PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+
<ItemGroup>
<PackageReference Include="OpenTK.NetStandard" Version="1.0.4" />
+ <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.1" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Ryujinx.Common\Ryujinx.Common.csproj" />
</ItemGroup>
+ <ItemGroup>
+ <ContentWithTargetPath Include="Native\libsoundio\libs\libsoundio.dll">
+ <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+ <TargetPath>libsoundio.dll</TargetPath>
+ </ContentWithTargetPath>
+ <ContentWithTargetPath Include="Native\libsoundio\libs\libsoundio.dylib">
+ <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+ <TargetPath>libsoundio.dylib</TargetPath>
+ </ContentWithTargetPath>
+ <ContentWithTargetPath Include="Native\libsoundio\libs\libsoundio.so">
+ <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+ <TargetPath>libsoundio.so</TargetPath>
+ </ContentWithTargetPath>
+ </ItemGroup>
+
</Project>
diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
index aae45081be..50a87893b5 100644
--- a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
+++ b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
@@ -8,6 +8,8 @@ using Ryujinx.HLE.Utilities;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
{
@@ -303,7 +305,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
}
}
- private void AppendMixedBuffer(long Tag)
+ private unsafe void AppendMixedBuffer(long Tag)
{
int[] MixBuffer = new int[MixBufferSamplesCount * AudioConsts.HostChannelsCount];
@@ -314,9 +316,9 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
continue;
}
- int OutOffset = 0;
-
- int PendingSamples = MixBufferSamplesCount;
+ int OutOffset = 0;
+ int PendingSamples = MixBufferSamplesCount;
+ float Volume = Voice.Volume;
while (PendingSamples > 0)
{
@@ -331,9 +333,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
for (int Offset = 0; Offset < Samples.Length; Offset++)
{
- int Sample = (int)(Samples[Offset] * Voice.Volume);
-
- MixBuffer[OutOffset++] += Sample;
+ MixBuffer[OutOffset++] += (int)(Samples[Offset] * Voice.Volume);
}
}
}
@@ -341,11 +341,49 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
AudioOut.AppendBuffer(Track, Tag, GetFinalBuffer(MixBuffer));
}
- private static short[] GetFinalBuffer(int[] Buffer)
+ private unsafe static short[] GetFinalBuffer(int[] Buffer)
{
short[] Output = new short[Buffer.Length];
- for (int Offset = 0; Offset < Buffer.Length; Offset++)
+ int Offset = 0;
+
+ // Perform Saturation using SSE2 if supported
+ if (Sse2.IsSupported)
+ {
+ fixed (int* inptr = Buffer)
+ fixed (short* outptr = Output)
+ {
+ for (; Offset + 32 <= Buffer.Length; Offset += 32)
+ {
+ // Unroll the loop a little to ensure the CPU pipeline
+ // is always full.
+ Vector128<int> block1A = Sse2.LoadVector128(inptr + Offset + 0);
+ Vector128<int> block1B = Sse2.LoadVector128(inptr + Offset + 4);
+
+ Vector128<int> block2A = Sse2.LoadVector128(inptr + Offset + 8);
+ Vector128<int> block2B = Sse2.LoadVector128(inptr + Offset + 12);
+
+ Vector128<int> block3A = Sse2.LoadVector128(inptr + Offset + 16);
+ Vector128<int> block3B = Sse2.LoadVector128(inptr + Offset + 20);
+
+ Vector128<int> block4A = Sse2.LoadVector128(inptr + Offset + 24);
+ Vector128<int> block4B = Sse2.LoadVector128(inptr + Offset + 28);
+
+ Vector128<short> output1 = Sse2.PackSignedSaturate(block1A, block1B);
+ Vector128<short> output2 = Sse2.PackSignedSaturate(block2A, block2B);
+ Vector128<short> output3 = Sse2.PackSignedSaturate(block3A, block3B);
+ Vector128<short> output4 = Sse2.PackSignedSaturate(block4A, block4B);
+
+ Sse2.Store(outptr + Offset + 0, output1);
+ Sse2.Store(outptr + Offset + 8, output2);
+ Sse2.Store(outptr + Offset + 16, output3);
+ Sse2.Store(outptr + Offset + 24, output4);
+ }
+ }
+ }
+
+ // Process left overs
+ for (; Offset < Buffer.Length; Offset++)
{
Output[Offset] = DspUtils.Saturate(Buffer[Offset]);
}
diff --git a/Ryujinx/Ui/Program.cs b/Ryujinx/Program.cs
similarity index 79%
rename from Ryujinx/Ui/Program.cs
rename to Ryujinx/Program.cs
index 4edf6e4714..f1d0a2ff9d 100644
--- a/Ryujinx/Ui/Program.cs
+++ b/Ryujinx/Program.cs
@@ -1,5 +1,4 @@
using Ryujinx.Audio;
-using Ryujinx.Audio.OpenAL;
using Ryujinx.Common.Logging;
using Ryujinx.Graphics.Gal;
using Ryujinx.Graphics.Gal.OpenGL;
@@ -17,7 +16,7 @@ namespace Ryujinx
IGalRenderer renderer = new OGLRenderer();
- IAalOutput audioOut = new OpenALAudioOut();
+ IAalOutput audioOut = InitializeAudioEngine();
Switch device = new Switch(renderer, audioOut);
@@ -86,5 +85,25 @@ namespace Ryujinx
audioOut.Dispose();
}
+
+ /// <summary>
+ /// Picks an <see cref="IAalOutput"/> audio output renderer supported on this machine
+ /// </summary>
+ /// <returns>An <see cref="IAalOutput"/> supported by this machine</returns>
+ private static IAalOutput InitializeAudioEngine()
+ {
+ if (SoundIoAudioOut.IsSupported)
+ {
+ return new SoundIoAudioOut();
+ }
+ else if (OpenALAudioOut.IsSupported)
+ {
+ return new OpenALAudioOut();
+ }
+ else
+ {
+ return new DummyAudioOut();
+ }
+ }
}
}
diff --git a/Ryujinx/Ryujinx.csproj b/Ryujinx/Ryujinx.csproj
index 7bc30d104e..1789ef2e9f 100644
--- a/Ryujinx/Ryujinx.csproj
+++ b/Ryujinx/Ryujinx.csproj
@@ -9,7 +9,6 @@
<ItemGroup>
<PackageReference Include="OpenTK.NetStandard" Version="1.0.4" />
- <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.4.0" />
</ItemGroup>
<ItemGroup>