From 8275bc3c087830baf84ef7ac236fade24988b522 Mon Sep 17 00:00:00 2001 From: jduncanator 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() Built-in `SizeOf()` is 10x faster than our `TypeSize` 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 1dfac377f..119fc2342 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(int Track, long Tag, T[] Buffer) where T : struct; + void AppendBuffer(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 000000000..ec3eef375 --- /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 000000000..e9ab9e6e1 --- /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 handle; + + public SoundIO () + { + handle = Natives.soundio_create (); + } + + internal SoundIO (Pointer 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 allocated_hglobals = new List (); + + 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 ("app_name"); + + public SoundIOBackend CurrentBackend { + get { return (SoundIOBackend) Marshal.ReadInt32 (handle, current_backend_offset); } + } + static readonly int current_backend_offset = (int)Marshal.OffsetOf ("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 ("emit_rtprio_warning"); + Action emit_rtprio_warning; + + // jack_error_callback + public Action 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 ("jack_error_callback"); + Action jack_error_callback; + delegate void jack_error_delegate (string message); + jack_error_delegate jack_error_callback_native; + + // jack_info_callback + public Action 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 ("jack_info_callback"); + Action jack_info_callback; + delegate void jack_info_delegate (string message); + jack_info_delegate jack_info_callback_native; + + // on_backend_disconnect + public Action 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 ("on_backend_disconnect"); + Action 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 ("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 ("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 000000000..dfcb0a3f0 --- /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 000000000..f30e2bbb4 --- /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 handle) + { + this.handle = handle; + } + + Pointer 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 ("ptr"); + + public int Step { + get { return Marshal.ReadInt32 (handle, step_offset); } + } + static readonly int step_offset = (int)Marshal.OffsetOf ("step"); + } +} diff --git a/Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs b/Ryujinx.Audio/Native/libsoundio/SoundIOChannelAreas.cs new file mode 100644 index 000000000..776d657ac --- /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 (); + + 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 000000000..d24508a1f --- /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 000000000..ee6345420 --- /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 handle) + { + this.handle = handle; + } + + readonly Pointer 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 ("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 ("name"); + + public IEnumerable 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 ("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 000000000..81b78b679 --- /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 handle) + { + this.handle = handle; + } + + readonly Pointer 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 ("aim"); + + public SoundIOFormat CurrentFormat { + get { return (SoundIOFormat) Marshal.ReadInt32 (handle, current_format_offset); } + } + static readonly int current_format_offset = (int)Marshal.OffsetOf ("current_format"); + + public SoundIOChannelLayout CurrentLayout { + get { return new SoundIOChannelLayout ((IntPtr) handle + current_layout_offset); + } + } + static readonly int current_layout_offset = (int)Marshal.OffsetOf ("current_layout"); + + public int FormatCount { + get { return Marshal.ReadInt32 (handle, format_count_offset); } + } + static readonly int format_count_offset = (int)Marshal.OffsetOf ("format_count"); + + public IEnumerable 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 ("formats"); + + public string Id { + get { return Marshal.PtrToStringAnsi (Marshal.ReadIntPtr (handle, id_offset)); } + } + static readonly int id_offset = (int)Marshal.OffsetOf ("id"); + + public bool IsRaw { + get { return Marshal.ReadInt32 (handle, is_raw_offset) != 0; } + } + static readonly int is_raw_offset = (int)Marshal.OffsetOf ("is_raw"); + + public int LayoutCount { + get { return Marshal.ReadInt32 (handle, layout_count_offset); } + } + static readonly int layout_count_offset = (int)Marshal.OffsetOf ("layout_count"); + + public IEnumerable Layouts { + get { + var ptr = Marshal.ReadIntPtr (handle, layouts_offset); + for (int i = 0; i < LayoutCount; i++) + yield return new SoundIOChannelLayout (ptr + i * Marshal.SizeOf ()); + } + } + static readonly int layouts_offset = (int) Marshal.OffsetOf ("layouts"); + + public string Name { + get { return Marshal.PtrToStringAnsi (Marshal.ReadIntPtr (handle, name_offset)); } + } + static readonly int name_offset = (int)Marshal.OffsetOf ("name"); + + public int ProbeError { + get { return Marshal.ReadInt32 (handle, probe_error_offset); } + } + static readonly int probe_error_offset = (int)Marshal.OffsetOf ("probe_error"); + + public int ReferenceCount { + get { return Marshal.ReadInt32 (handle, ref_count_offset); } + } + static readonly int ref_count_offset = (int)Marshal.OffsetOf ("ref_count"); + + public int SampleRateCount { + get { return Marshal.ReadInt32 (handle, sample_rate_count_offset); } + } + static readonly int sample_rate_count_offset = (int)Marshal.OffsetOf ("sample_rate_count"); + + public IEnumerable 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 ("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 ("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 ("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 ("software_latency_max"); + + public SoundIO SoundIO { + get { return new SoundIO (Marshal.ReadIntPtr (handle, soundio_offset)); } + } + static readonly int soundio_offset = (int)Marshal.OffsetOf ("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 000000000..9cd45f36f --- /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 000000000..ff6a0337b --- /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 000000000..59434e1e5 --- /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 000000000..fb0b31045 --- /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 handle) + { + this.handle = handle; + } + + Pointer 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 ("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 ("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 ("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 (), Marshal.SizeOf ()); + } + } + } + static readonly int layout_offset = (int)Marshal.OffsetOf ("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 ("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 ("error_callback"); + Action error_callback; + delegate void error_callback_delegate (IntPtr handle); + error_callback_delegate error_callback_native; + + // read_callback + public Action 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 ("read_callback"); + Action 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 ("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 allocated_hglobals = new List (); + + 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 ("name"); + + public bool NonTerminalHint { + get { return Marshal.ReadInt32 (handle, non_terminal_hint_offset) != 0; } + } + static readonly int non_terminal_hint_offset = (int)Marshal.OffsetOf ("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 ("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 ("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 ("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 000000000..0b77e1af8 --- /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 handle) + { + this.handle = handle; + } + + Pointer 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 ("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 ("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 ("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 (), Marshal.SizeOf ()); + } + } + } + static readonly int layout_offset = (int)Marshal.OffsetOf ("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 ("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 ("error_callback"); + Action error_callback; + delegate void error_callback_delegate (IntPtr handle); + error_callback_delegate error_callback_native; + + // write_callback + public Action 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 ("write_callback"); + Action 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 ("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 allocated_hglobals = new List (); + + 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 ("name"); + + public bool NonTerminalHint { + get { return Marshal.ReadInt32 (handle, non_terminal_hint_offset) != 0; } + } + static readonly int non_terminal_hint_offset = (int)Marshal.OffsetOf ("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 ("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 ("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 ("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 000000000..63d796fd5 --- /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 000000000..28fee4585 --- /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 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�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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

X>1^8Z_^p{nY_#>$?ffD^ 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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 000000000..6eb09370f --- /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")] public System.IntPtr @name; + public int @channel_count; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + [CTypeDetails("ConstArrayOf")] 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")] public System.IntPtr @ptr; + public int @step; + } + + [StructLayout(LayoutKind.Sequential)] + struct SoundIo // soundio.h (324, 8) + { + [CTypeDetails("Pointer")] public System.IntPtr @userdata; + [CTypeDetails("Pointer")] public delegate0 @on_devices_change; + [CTypeDetails("Pointer")] public delegate1 @on_backend_disconnect; + [CTypeDetails("Pointer")] public Delegates.delegate0 @on_events_signal; + public SoundIoBackend @current_backend; + [CTypeDetails("Pointer")] public System.IntPtr @app_name; + [CTypeDetails("Pointer")] public delegate2 @emit_rtprio_warning; + [CTypeDetails("Pointer")] public delegate3 @jack_info_callback; + [CTypeDetails("Pointer")] public Delegates.delegate3 @jack_error_callback; + } + + [StructLayout(LayoutKind.Sequential)] + struct SoundIoDevice // soundio.h (383, 8) + { + [CTypeDetails("Pointer")] public System.IntPtr @soundio; + [CTypeDetails("Pointer")] public System.IntPtr @id; + [CTypeDetails("Pointer")] public System.IntPtr @name; + public SoundIoDeviceAim @aim; + [CTypeDetails("Pointer")] public System.IntPtr @layouts; + public int @layout_count; + public SoundIoChannelLayout @current_layout; + [CTypeDetails("Pointer")] public System.IntPtr @formats; + public int @format_count; + public SoundIoFormat @current_format; + [CTypeDetails("Pointer")] 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")] public System.IntPtr @device; + public SoundIoFormat @format; + public int @sample_rate; + public SoundIoChannelLayout @layout; + public double @software_latency; + [CTypeDetails("Pointer")] public System.IntPtr @userdata; + [CTypeDetails("Pointer")] public delegate4 @write_callback; + [CTypeDetails("Pointer")] public delegate5 @underflow_callback; + [CTypeDetails("Pointer")] public delegate6 @error_callback; + [CTypeDetails("Pointer")] 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")] public System.IntPtr @device; + public SoundIoFormat @format; + public int @sample_rate; + public SoundIoChannelLayout @layout; + public double @software_latency; + [CTypeDetails("Pointer")] public System.IntPtr @userdata; + [CTypeDetails("Pointer")] public delegate7 @read_callback; + [CTypeDetails("Pointer")] public delegate8 @overflow_callback; + [CTypeDetails("Pointer")] public delegate9 @error_callback; + [CTypeDetails("Pointer")] 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")]System.IntPtr @soundio); + + // function soundio_connect - soundio.h (700, 20) + [DllImport(LibraryName)] + internal static extern int soundio_connect([CTypeDetails("Pointer")]System.IntPtr @soundio); + + // function soundio_connect_backend - soundio.h (712, 20) + [DllImport(LibraryName)] + internal static extern int soundio_connect_backend([CTypeDetails("Pointer")]System.IntPtr @soundio, SoundIoBackend @backend); + + // function soundio_disconnect - soundio.h (713, 21) + [DllImport(LibraryName)] + internal static extern void soundio_disconnect([CTypeDetails("Pointer")]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")]System.IntPtr @soundio); + + // function soundio_get_backend - soundio.h (724, 36) + [DllImport(LibraryName)] + internal static extern SoundIoBackend soundio_get_backend([CTypeDetails("Pointer")]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")]System.IntPtr @soundio); + + // function soundio_wait_events - soundio.h (755, 21) + [DllImport(LibraryName)] + internal static extern void soundio_wait_events([CTypeDetails("Pointer")]System.IntPtr @soundio); + + // function soundio_wakeup - soundio.h (758, 21) + [DllImport(LibraryName)] + internal static extern void soundio_wakeup([CTypeDetails("Pointer")]System.IntPtr @soundio); + + // function soundio_force_device_scan - soundio.h (775, 21) + [DllImport(LibraryName)] + internal static extern void soundio_force_device_scan([CTypeDetails("Pointer")]System.IntPtr @soundio); + + // function soundio_channel_layout_equal - soundio.h (782, 21) + [DllImport(LibraryName)] + internal static extern bool soundio_channel_layout_equal([CTypeDetails("Pointer")]System.IntPtr @a, [CTypeDetails("Pointer")]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")]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")]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")]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")]System.IntPtr @preferred_layouts, int @preferred_layout_count, [CTypeDetails("Pointer")]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")]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")]System.IntPtr @soundio); + + // function soundio_output_device_count - soundio.h (859, 20) + [DllImport(LibraryName)] + internal static extern int soundio_output_device_count([CTypeDetails("Pointer")]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")]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")]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")]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")]System.IntPtr @soundio); + + // function soundio_device_ref - soundio.h (883, 21) + [DllImport(LibraryName)] + internal static extern void soundio_device_ref([CTypeDetails("Pointer")]System.IntPtr @device); + + // function soundio_device_unref - soundio.h (886, 21) + [DllImport(LibraryName)] + internal static extern void soundio_device_unref([CTypeDetails("Pointer")]System.IntPtr @device); + + // function soundio_device_equal - soundio.h (890, 21) + [DllImport(LibraryName)] + internal static extern bool soundio_device_equal([CTypeDetails("Pointer")]System.IntPtr @a, [CTypeDetails("Pointer")]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")]System.IntPtr @device); + + // function soundio_device_supports_format - soundio.h (899, 21) + [DllImport(LibraryName)] + internal static extern bool soundio_device_supports_format([CTypeDetails("Pointer")]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")]System.IntPtr @device, [CTypeDetails("Pointer")]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")]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")]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")]System.IntPtr @device); + + // function soundio_outstream_destroy - soundio.h (926, 21) + [DllImport(LibraryName)] + internal static extern void soundio_outstream_destroy([CTypeDetails("Pointer")]System.IntPtr @outstream); + + // function soundio_outstream_open - soundio.h (950, 20) + [DllImport(LibraryName)] + internal static extern int soundio_outstream_open([CTypeDetails("Pointer")]System.IntPtr @outstream); + + // function soundio_outstream_start - soundio.h (961, 20) + [DllImport(LibraryName)] + internal static extern int soundio_outstream_start([CTypeDetails("Pointer")]System.IntPtr @outstream); + + // function soundio_outstream_begin_write - soundio.h (993, 20) + [DllImport(LibraryName)] + internal static extern int soundio_outstream_begin_write([CTypeDetails("Pointer")]System.IntPtr @outstream, [CTypeDetails("Pointer")]System.IntPtr @areas, [CTypeDetails("Pointer")]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")]System.IntPtr @outstream); + + // function soundio_outstream_clear_buffer - soundio.h (1020, 20) + [DllImport(LibraryName)] + internal static extern int soundio_outstream_clear_buffer([CTypeDetails("Pointer")]System.IntPtr @outstream); + + // function soundio_outstream_pause - soundio.h (1041, 20) + [DllImport(LibraryName)] + internal static extern int soundio_outstream_pause([CTypeDetails("Pointer")]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")]System.IntPtr @outstream, [CTypeDetails("Pointer")]System.IntPtr @out_latency); + + // function soundio_instream_create - soundio.h (1064, 40) + [DllImport(LibraryName)] + internal static extern System.IntPtr soundio_instream_create([CTypeDetails("Pointer")]System.IntPtr @device); + + // function soundio_instream_destroy - soundio.h (1066, 21) + [DllImport(LibraryName)] + internal static extern void soundio_instream_destroy([CTypeDetails("Pointer")]System.IntPtr @instream); + + // function soundio_instream_open - soundio.h (1086, 20) + [DllImport(LibraryName)] + internal static extern int soundio_instream_open([CTypeDetails("Pointer")]System.IntPtr @instream); + + // function soundio_instream_start - soundio.h (1095, 20) + [DllImport(LibraryName)] + internal static extern int soundio_instream_start([CTypeDetails("Pointer")]System.IntPtr @instream); + + // function soundio_instream_begin_read - soundio.h (1126, 20) + [DllImport(LibraryName)] + internal static extern int soundio_instream_begin_read([CTypeDetails("Pointer")]System.IntPtr @instream, [CTypeDetails("Pointer")]System.IntPtr @areas, [CTypeDetails("Pointer")]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")]System.IntPtr @instream); + + // function soundio_instream_pause - soundio.h (1149, 20) + [DllImport(LibraryName)] + internal static extern int soundio_instream_pause([CTypeDetails("Pointer")]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")]System.IntPtr @instream, [CTypeDetails("Pointer")]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")]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")]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")]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")]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")]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")]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")]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")]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")]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")]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 + { + public IntPtr Handle; + public static implicit operator IntPtr(Pointer value) { return value.Handle; } + public static implicit operator Pointer(IntPtr value) { return new Pointer(value); } + + public Pointer(IntPtr handle) + { + Handle = handle; + } + + public override bool Equals(object obj) + { + return obj is Pointer && this == (Pointer)obj; + } + + public override int GetHashCode() + { + return (int)Handle; + } + + public static bool operator ==(Pointer p1, Pointer p2) + { + return p1.Handle == p2.Handle; + } + + public static bool operator !=(Pointer p1, Pointer p2) + { + return p1.Handle != p2.Handle; + } + } + public struct ArrayOf { } + public struct ConstArrayOf { } + 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 8b53128aa..7d8620924 100644 --- a/Ryujinx.Audio/PlaybackState.cs +++ b/Ryujinx.Audio/PlaybackState.cs @@ -1,8 +1,17 @@ namespace Ryujinx.Audio { + ///

+ /// The playback state of a track + /// public enum PlaybackState { + /// + /// The track is currently playing + /// Playing = 0, + /// + /// The track is currently stopped + /// 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 000000000..659734b6d --- /dev/null +++ b/Ryujinx.Audio/Renderers/DummyAudioOut.cs @@ -0,0 +1,63 @@ +using System.Collections.Concurrent; +using System.Collections.Generic; + +namespace Ryujinx.Audio +{ + /// + /// A Dummy audio renderer that does not output any audio + /// + public class DummyAudioOut : IAalOutput + { + private ConcurrentQueue m_Buffers; + + public DummyAudioOut() + { + m_Buffers = new ConcurrentQueue(); + } + + /// + /// Dummy audio output is always available, Baka! + /// + 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(int trackID, long bufferTag, T[] buffer) + where T : struct + { + m_Buffers.Enqueue(bufferTag); + } + + public long[] GetReleasedBuffers(int trackId, int maxCount) + { + List bufferTags = new List(); + + 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 9a75c5685..93f928791 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 { + /// + /// An audio renderer that uses OpenAL as the audio backend + /// public class OpenALAudioOut : IAalOutput, IDisposable { private const int MaxTracks = 256; @@ -176,6 +179,24 @@ namespace Ryujinx.Audio.OpenAL AudioPollerThread.Start(); } + /// + /// True if OpenAL is supported on the device. + /// + 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 000000000..76b1290d1 --- /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 +{ + /// + /// An audio renderer that uses libsoundio as the audio backend + /// + public class SoundIoAudioOut : IAalOutput + { + /// + /// The maximum amount of tracks we can issue simultaneously + /// + private const int MaximumTracks = 256; + + /// + /// The audio context + /// + private SoundIO m_AudioContext; + + /// + /// The audio device + /// + private SoundIODevice m_AudioDevice; + + /// + /// An object pool containing objects + /// + private SoundIoAudioTrackPool m_TrackPool; + + /// + /// True if SoundIO is supported on the device. + /// + public static bool IsSupported => true; + + /// + /// Constructs a new instance of a + /// + 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); + } + + /// + /// Gets the current playback state of the specified track + /// + /// The track to retrieve the playback state for + public PlaybackState GetState(int trackId) + { + if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + return track.State; + } + + return PlaybackState.Stopped; + } + + /// + /// Creates a new audio track with the specified parameters + /// + /// The requested sample rate + /// The requested channels + /// A that represents the delegate to invoke when a buffer has been released by the audio track + /// The created track's Track ID + 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; + } + + /// + /// Stops playback and closes the track specified by + /// + /// The ID of the track to close + 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); + } + } + + /// + /// Starts playback + /// + /// The ID of the track to start playback on + public void Start(int trackId) + { + if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + track.Start(); + } + } + + /// + /// Stops playback + /// + /// The ID of the track to stop playback on + public void Stop(int trackId) + { + if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + track.Stop(); + } + } + + /// + /// Appends an audio buffer to the specified track + /// + /// The sample type of the buffer + /// The track to append the buffer to + /// The internal tag of the buffer + /// The buffer to append to the track + public void AppendBuffer(int trackId, long bufferTag, T[] buffer) + where T : struct + { + if(m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + track.AppendBuffer(bufferTag, buffer); + } + } + + /// + /// Returns a value indicating whether the specified buffer is currently reserved by the specified track + /// + /// The track to check + /// The buffer tag to check + public bool ContainsBuffer(int trackId, long bufferTag) + { + if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + return track.ContainsBuffer(bufferTag); + } + + return false; + } + + /// + /// Gets a list of buffer tags the specified track is no longer reserving + /// + /// The track to retrieve buffer tags from + /// The maximum amount of buffer tags to retrieve + /// Buffers released by the specified track + public long[] GetReleasedBuffers(int trackId, int maxCount) + { + if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) + { + List bufferTags = new List(); + + while(maxCount-- > 0 && track.ReleasedBuffers.TryDequeue(out long tag)) + { + bufferTags.Add(tag); + } + + return bufferTags.ToArray(); + } + + return new long[0]; + } + + /// + /// Releases the unmanaged resources used by the + /// + 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 000000000..97ba11d51 --- /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 + { + /// + /// The audio track ring buffer + /// + private SoundIoRingBuffer m_Buffer; + + /// + /// A list of buffers currently pending writeback to the audio backend + /// + private ConcurrentQueue m_ReservedBuffers; + + /// + /// Occurs when a buffer has been released by the audio backend + /// + private event ReleaseCallback BufferReleased; + + /// + /// The track ID of this + /// + public int TrackID { get; private set; } + + /// + /// The current playback state + /// + public PlaybackState State { get; private set; } + + /// + /// The audio context this track belongs to + /// + public SoundIO AudioContext { get; private set; } + + /// + /// The this track belongs to + /// + public SoundIODevice AudioDevice { get; private set; } + + /// + /// The audio output stream of this track + /// + public SoundIOOutStream AudioStream { get; private set; } + + /// + /// Released buffers the track is no longer holding + /// + public ConcurrentQueue ReleasedBuffers { get; private set; } + + /// + /// Constructs a new instance of a + /// + /// The track ID + /// The SoundIO audio context + /// The SoundIO audio device + public SoundIoAudioTrack(int trackId, SoundIO audioContext, SoundIODevice audioDevice) + { + TrackID = trackId; + AudioContext = audioContext; + AudioDevice = audioDevice; + State = PlaybackState.Stopped; + ReleasedBuffers = new ConcurrentQueue(); + + m_Buffer = new SoundIoRingBuffer(); + m_ReservedBuffers = new ConcurrentQueue(); + } + + /// + /// Opens the audio track with the specified parameters + /// + /// The requested sample rate of the track + /// The requested channel count of the track + /// A that represents the delegate to invoke when a buffer has been released by the audio track + /// The requested sample format of the track + 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(); + } + + /// + /// This callback occurs when the sound device is ready to buffer more frames + /// + /// The minimum amount of frames expected by the audio backend + /// The maximum amount of frames that can be written to the audio backend + 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); + } + + /// + /// Releases any buffers that have been fully written to the output device + /// + /// The amount of bytes written in the last device write + 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(); + } + } + + /// + /// Starts audio playback + /// + public void Start() + { + if (AudioStream == null) + { + return; + } + + AudioStream.Start(); + AudioStream.Pause(false); + AudioContext.FlushEvents(); + State = PlaybackState.Playing; + } + + /// + /// Stops audio playback + /// + public void Stop() + { + if (AudioStream == null) + { + return; + } + + AudioStream.Pause(true); + AudioContext.FlushEvents(); + State = PlaybackState.Stopped; + } + + /// + /// Appends an audio buffer to the tracks internal ring buffer + /// + /// The audio sample type + /// The unqiue tag of the buffer being appended + /// The buffer to append + public void AppendBuffer(long bufferTag, T[] buffer) + { + if (AudioStream == null) + { + return; + } + + // Calculate the size of the audio samples + int size = Unsafe.SizeOf(); + + // 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)); + } + + /// + /// Returns a value indicating whether the specified buffer is currently reserved by the track + /// + /// The buffer tag to check + public bool ContainsBuffer(long bufferTag) + { + return m_ReservedBuffers.Any(x => x.Tag == bufferTag); + } + + /// + /// Closes the + /// + 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(); + } + + /// + /// Releases the unmanaged resources used by the + /// + 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 000000000..ec256e208 --- /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 +{ + /// + /// An object pool containing a set of audio tracks + /// + internal class SoundIoAudioTrackPool : IDisposable + { + /// + /// The current size of the + /// + private int m_Size; + + /// + /// The maximum size of the + /// + private int m_MaxSize; + + /// + /// The audio context this track pool belongs to + /// + private SoundIO m_Context; + + /// + /// The audio device this track pool belongs to + /// + private SoundIODevice m_Device; + + /// + /// The queue that keeps track of the available in the pool. + /// + private ConcurrentQueue m_Queue; + + /// + /// The dictionary providing mapping between a TrackID and + /// + private ConcurrentDictionary m_TrackList; + + /// + /// Gets the current size of the + /// + public int Size { get => m_Size; } + + /// + /// Gets the maximum size of the + /// + public int MaxSize { get => m_MaxSize; } + + /// + /// Gets a value that indicates whether the is empty + /// + public bool IsEmpty { get => m_Queue.IsEmpty; } + + /// + /// Constructs a new instance of a that is empty + /// + /// The maximum amount of tracks that can be created + public SoundIoAudioTrackPool(SoundIO context, SoundIODevice device, int maxSize) + { + m_Size = 0; + m_Context = context; + m_Device = device; + m_MaxSize = maxSize; + + m_Queue = new ConcurrentQueue(); + m_TrackList = new ConcurrentDictionary(); + } + + /// + /// Constructs a new instance of a that contains + /// the specified amount of + /// + /// The maximum amount of tracks that can be created + /// The initial number of tracks that the pool contains + 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(trackCollection); + } + + /// + /// Creates a new with the proper AudioContext and AudioDevice + /// and the specified + /// + /// The ID of the track to be created + /// A new AudioTrack with the specified ID + 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; + } + + /// + /// Retrieves a from the pool + /// + /// An AudioTrack from the pool + 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++); + } + + /// + /// Retrieves the associated with the specified from the pool + /// + /// The ID of the track to retrieve + public SoundIoAudioTrack Get(int trackId) + { + if (m_TrackList.TryGetValue(trackId, out SoundIoAudioTrack track)) + { + return track; + } + + return null; + } + + /// + /// Attempers to get a from the pool + /// + /// The track retrieved from the pool + /// True if retrieve was successful + public bool TryGet(out SoundIoAudioTrack track) + { + track = Get(); + + return track != null; + } + + /// + /// Attempts to get the associated with the specified from the pool + /// + /// The ID of the track to retrieve + /// The track retrieved from the pool + public bool TryGet(int trackId, out SoundIoAudioTrack track) + { + return m_TrackList.TryGetValue(trackId, out track); + } + + /// + /// Returns an back to the pool for reuse + /// + /// The track to be returned to the pool + 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); + } + + /// + /// Releases the unmanaged resources used by the + /// + 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 000000000..2a6190b53 --- /dev/null +++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoBuffer.cs @@ -0,0 +1,29 @@ +namespace Ryujinx.Audio.SoundIo +{ + /// + /// Represents the remaining bytes left buffered for a specific buffer tag + /// + internal class SoundIoBuffer + { + /// + /// The buffer tag this represents + /// + public long Tag { get; private set; } + + /// + /// The remaining bytes still to be released + /// + public int Length { get; set; } + + /// + /// Constructs a new instance of a + /// + /// The buffer tag + /// The size of the buffer + 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 000000000..b28850213 --- /dev/null +++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoRingBuffer.cs @@ -0,0 +1,204 @@ +using System; + +namespace Ryujinx.Audio.SoundIo +{ + /// + /// A thread-safe variable-size circular buffer + /// + internal class SoundIoRingBuffer + { + private byte[] m_Buffer; + private int m_Size; + private int m_HeadOffset; + private int m_TailOffset; + + /// + /// Gets the available bytes in the ring buffer + /// + public int Length + { + get { return m_Size; } + } + + /// + /// Constructs a new instance of a + /// + public SoundIoRingBuffer() + { + m_Buffer = new byte[2048]; + } + + /// + /// Constructs a new instance of a with the specified capacity + /// + /// The number of entries that the can initially contain + public SoundIoRingBuffer(int capacity) + { + m_Buffer = new byte[capacity]; + } + + /// + /// Clears the ring buffer + /// + public void Clear() + { + m_Size = 0; + m_HeadOffset = 0; + m_TailOffset = 0; + } + + /// + /// Clears the specified amount of bytes from the ring buffer + /// + /// The amount of bytes to clear from the ring buffer + 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; + } + } + + /// + /// Extends the capacity of the ring buffer + /// + 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; + } + + + /// + /// Writes a sequence of bytes to the ring buffer + /// + /// A byte array containing the data to write + /// The zero-based byte offset in from which to begin copying bytes to the ring buffer + /// The number of bytes to write + public void Write(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; + } + } + + /// + /// Reads a sequence of bytes from the ring buffer and advances the position within the ring buffer by the number of bytes read + /// + /// The buffer to write the data into + /// The zero-based byte offset in at which the read bytes will be placed + /// The maximum number of bytes to read + /// 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 + public int Read(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 3fc611709..82d2a4d15 100644 --- a/Ryujinx.Audio/Ryujinx.Audio.csproj +++ b/Ryujinx.Audio/Ryujinx.Audio.csproj @@ -5,12 +5,36 @@ win10-x64;osx-x64;linux-x64 + + true + + + + true + + + + + + PreserveNewest + libsoundio.dll + + + PreserveNewest + libsoundio.dylib + + + PreserveNewest + libsoundio.so + + + diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs index aae45081b..50a87893b 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 block1A = Sse2.LoadVector128(inptr + Offset + 0); + Vector128 block1B = Sse2.LoadVector128(inptr + Offset + 4); + + Vector128 block2A = Sse2.LoadVector128(inptr + Offset + 8); + Vector128 block2B = Sse2.LoadVector128(inptr + Offset + 12); + + Vector128 block3A = Sse2.LoadVector128(inptr + Offset + 16); + Vector128 block3B = Sse2.LoadVector128(inptr + Offset + 20); + + Vector128 block4A = Sse2.LoadVector128(inptr + Offset + 24); + Vector128 block4B = Sse2.LoadVector128(inptr + Offset + 28); + + Vector128 output1 = Sse2.PackSignedSaturate(block1A, block1B); + Vector128 output2 = Sse2.PackSignedSaturate(block2A, block2B); + Vector128 output3 = Sse2.PackSignedSaturate(block3A, block3B); + Vector128 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 4edf6e471..f1d0a2ff9 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(); } + + /// + /// Picks an audio output renderer supported on this machine + /// + /// An supported by this machine + 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 7bc30d104..1789ef2e9 100644 --- a/Ryujinx/Ryujinx.csproj +++ b/Ryujinx/Ryujinx.csproj @@ -9,7 +9,6 @@ -