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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

KhY6}`N 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�b-7DdEN0>gF( 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 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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�gRSCiaudC^0 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 literal 0 HcmV?d00001 diff --git a/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.so b/Ryujinx.Audio/Native/libsoundio/libs/libsoundio.so new file mode 100644 index 0000000000000000000000000000000000000000..2b9cf1b30e77113a78fecee889b809d408aa6b8d GIT binary patch literal 265888 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 Nj)NY{50^yO4*=>N^2q=I 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 @@ -