mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
* Haydn: Part 1 Based on my reverse of audio 11.0.0. As always, core implementation under LGPLv3 for the same reasons as for Amadeus. This place the bases of a more flexible audio system while making audout & audin accurate. This have the following improvements: - Complete reimplementation of audout and audin. - Audin currently only have a dummy backend. - Dramatically reduce CPU usage by up to 50% in common cases (SoundIO and OpenAL). - Audio Renderer now can output to 5.1 devices when supported. - Audio Renderer init its backend on demand instead of keeping two up all the time. - All backends implementation are now in their own project. - Ryujinx.Audio.Renderer was renamed Ryujinx.Audio and was refactored because of this. As a note, games having issues with OpenAL haven't improved and will not because of OpenAL design (stopping when buffers finish playing causing possible audio "pops" when buffers are very small). * Update for latest hexkyz's edits on Switchbrew * audren: Rollback channel configuration changes * Address gdkchan's comments * Fix typo in OpenAL backend driver * Address last comments * Fix a nit * Address gdkchan's comments
386 lines
12 KiB
C#
386 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace SoundIOSharp
|
|
{
|
|
public class SoundIO : IDisposable
|
|
{
|
|
Pointer<SoundIo> handle;
|
|
|
|
public SoundIO()
|
|
{
|
|
handle = Natives.soundio_create();
|
|
}
|
|
|
|
internal SoundIO(Pointer<SoundIo> handle)
|
|
{
|
|
this.handle = handle;
|
|
}
|
|
|
|
public void Dispose ()
|
|
{
|
|
foreach (var h in allocated_hglobals)
|
|
{
|
|
Marshal.FreeHGlobal(h);
|
|
}
|
|
|
|
Natives.soundio_destroy(handle);
|
|
}
|
|
|
|
// Equality (based on handle)
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
var d = other as SoundIO;
|
|
|
|
return d != null && this.handle == d.handle;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return (int)(IntPtr)handle;
|
|
}
|
|
|
|
public static bool operator == (SoundIO obj1, SoundIO obj2)
|
|
{
|
|
return obj1 is null ? obj2 is null : obj1.Equals(obj2);
|
|
}
|
|
|
|
public static bool operator != (SoundIO obj1, SoundIO obj2)
|
|
{
|
|
return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
|
|
}
|
|
|
|
// fields
|
|
|
|
// FIXME: this should be taken care in more centralized/decent manner... we don't want to write
|
|
// this kind of code anywhere we need string marshaling.
|
|
List<IntPtr> allocated_hglobals = new List<IntPtr>();
|
|
|
|
public string ApplicationName {
|
|
get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, app_name_offset)); }
|
|
set
|
|
{
|
|
unsafe
|
|
{
|
|
var existing = Marshal.ReadIntPtr(handle, app_name_offset);
|
|
if (allocated_hglobals.Contains (existing))
|
|
{
|
|
allocated_hglobals.Remove(existing);
|
|
Marshal.FreeHGlobal(existing);
|
|
}
|
|
|
|
var ptr = Marshal.StringToHGlobalAnsi(value);
|
|
Marshal.WriteIntPtr(handle, app_name_offset, ptr);
|
|
allocated_hglobals.Add(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
static readonly int app_name_offset = (int)Marshal.OffsetOf<SoundIo>("app_name");
|
|
|
|
public SoundIOBackend CurrentBackend
|
|
{
|
|
get { return (SoundIOBackend)Marshal.ReadInt32(handle, current_backend_offset); }
|
|
}
|
|
|
|
static readonly int current_backend_offset = (int)Marshal.OffsetOf<SoundIo>("current_backend");
|
|
|
|
// emit_rtprio_warning
|
|
public Action EmitRealtimePriorityWarning
|
|
{
|
|
get { return emit_rtprio_warning; }
|
|
set
|
|
{
|
|
emit_rtprio_warning = value;
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(on_devices_change);
|
|
|
|
Marshal.WriteIntPtr(handle, emit_rtprio_warning_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int emit_rtprio_warning_offset = (int)Marshal.OffsetOf<SoundIo>("emit_rtprio_warning");
|
|
|
|
Action emit_rtprio_warning;
|
|
|
|
// jack_error_callback
|
|
public Action<string> JackErrorCallback
|
|
{
|
|
get { return jack_error_callback; }
|
|
set
|
|
{
|
|
jack_error_callback = value;
|
|
if (value == null)
|
|
{
|
|
jack_error_callback = null;
|
|
}
|
|
else
|
|
{
|
|
jack_error_callback_native = msg => jack_error_callback(msg);
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(jack_error_callback_native);
|
|
Marshal.WriteIntPtr(handle, jack_error_callback_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int jack_error_callback_offset = (int)Marshal.OffsetOf<SoundIo>("jack_error_callback");
|
|
|
|
Action<string> jack_error_callback;
|
|
delegate void jack_error_delegate(string message);
|
|
jack_error_delegate jack_error_callback_native;
|
|
|
|
// jack_info_callback
|
|
public Action<string> JackInfoCallback
|
|
{
|
|
get { return jack_info_callback; }
|
|
set
|
|
{
|
|
jack_info_callback = value;
|
|
if (value == null)
|
|
{
|
|
jack_info_callback = null;
|
|
}
|
|
else
|
|
{
|
|
jack_info_callback_native = msg => jack_info_callback(msg);
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(jack_info_callback_native);
|
|
Marshal.WriteIntPtr(handle, jack_info_callback_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int jack_info_callback_offset = (int)Marshal.OffsetOf<SoundIo>("jack_info_callback");
|
|
|
|
Action<string> jack_info_callback;
|
|
delegate void jack_info_delegate(string message);
|
|
jack_info_delegate jack_info_callback_native;
|
|
|
|
// on_backend_disconnect
|
|
public Action<int> OnBackendDisconnect
|
|
{
|
|
get { return on_backend_disconnect; }
|
|
set
|
|
{
|
|
on_backend_disconnect = value;
|
|
if (value == null)
|
|
{
|
|
on_backend_disconnect_native = null;
|
|
}
|
|
else
|
|
{
|
|
on_backend_disconnect_native = (sio, err) => on_backend_disconnect(err);
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(on_backend_disconnect_native);
|
|
Marshal.WriteIntPtr(handle, on_backend_disconnect_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int on_backend_disconnect_offset = (int)Marshal.OffsetOf<SoundIo>("on_backend_disconnect");
|
|
|
|
Action<int> on_backend_disconnect;
|
|
delegate void on_backend_disconnect_delegate(IntPtr handle, int errorCode);
|
|
on_backend_disconnect_delegate on_backend_disconnect_native;
|
|
|
|
// on_devices_change
|
|
public Action OnDevicesChange
|
|
{
|
|
get { return on_devices_change; }
|
|
set
|
|
{
|
|
on_devices_change = value;
|
|
if (value == null)
|
|
{
|
|
on_devices_change_native = null;
|
|
}
|
|
else
|
|
{
|
|
on_devices_change_native = sio => on_devices_change();
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(on_devices_change_native);
|
|
Marshal.WriteIntPtr(handle, on_devices_change_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int on_devices_change_offset = (int)Marshal.OffsetOf<SoundIo>("on_devices_change");
|
|
|
|
Action on_devices_change;
|
|
delegate void on_devices_change_delegate(IntPtr handle);
|
|
on_devices_change_delegate on_devices_change_native;
|
|
|
|
// on_events_signal
|
|
public Action OnEventsSignal
|
|
{
|
|
get { return on_events_signal; }
|
|
set
|
|
{
|
|
on_events_signal = value;
|
|
if (value == null)
|
|
{
|
|
on_events_signal_native = null;
|
|
}
|
|
else
|
|
{
|
|
on_events_signal_native = sio => on_events_signal();
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(on_events_signal_native);
|
|
Marshal.WriteIntPtr(handle, on_events_signal_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int on_events_signal_offset = (int)Marshal.OffsetOf<SoundIo>("on_events_signal");
|
|
|
|
Action on_events_signal;
|
|
delegate void on_events_signal_delegate(IntPtr handle);
|
|
on_events_signal_delegate on_events_signal_native;
|
|
|
|
|
|
// functions
|
|
|
|
public int BackendCount
|
|
{
|
|
get { return Natives.soundio_backend_count(handle); }
|
|
}
|
|
|
|
public int InputDeviceCount
|
|
{
|
|
get { return Natives.soundio_input_device_count(handle); }
|
|
}
|
|
|
|
public int OutputDeviceCount
|
|
{
|
|
get { return Natives.soundio_output_device_count(handle); }
|
|
}
|
|
|
|
public int DefaultInputDeviceIndex
|
|
{
|
|
get { return Natives.soundio_default_input_device_index(handle); }
|
|
}
|
|
|
|
public int DefaultOutputDeviceIndex
|
|
{
|
|
get { return Natives.soundio_default_output_device_index(handle); }
|
|
}
|
|
|
|
public SoundIOBackend GetBackend(int index)
|
|
{
|
|
return (SoundIOBackend)Natives.soundio_get_backend(handle, index);
|
|
}
|
|
|
|
public SoundIODevice GetInputDevice(int index)
|
|
{
|
|
return new SoundIODevice(Natives.soundio_get_input_device(handle, index));
|
|
}
|
|
|
|
public SoundIODevice GetOutputDevice(int index)
|
|
{
|
|
return new SoundIODevice(Natives.soundio_get_output_device(handle, index));
|
|
}
|
|
|
|
public void Connect()
|
|
{
|
|
var ret = (SoundIoError)Natives.soundio_connect(handle);
|
|
if (ret != SoundIoError.SoundIoErrorNone)
|
|
{
|
|
throw new SoundIOException(ret);
|
|
}
|
|
}
|
|
|
|
public void ConnectBackend(SoundIOBackend backend)
|
|
{
|
|
var ret = (SoundIoError)Natives.soundio_connect_backend(handle, (SoundIoBackend)backend);
|
|
if (ret != SoundIoError.SoundIoErrorNone)
|
|
{
|
|
throw new SoundIOException(ret);
|
|
}
|
|
}
|
|
|
|
public void Disconnect()
|
|
{
|
|
Natives.soundio_disconnect(handle);
|
|
}
|
|
|
|
public void FlushEvents()
|
|
{
|
|
Natives.soundio_flush_events(handle);
|
|
}
|
|
|
|
public void WaitEvents()
|
|
{
|
|
Natives.soundio_wait_events(handle);
|
|
}
|
|
|
|
public void Wakeup()
|
|
{
|
|
Natives.soundio_wakeup(handle);
|
|
}
|
|
|
|
public void ForceDeviceScan()
|
|
{
|
|
Natives.soundio_force_device_scan(handle);
|
|
}
|
|
|
|
public SoundIORingBuffer CreateRingBuffer(int capacity)
|
|
{
|
|
return new SoundIORingBuffer(Natives.soundio_ring_buffer_create(handle, capacity));
|
|
}
|
|
|
|
// static methods
|
|
|
|
public static string VersionString
|
|
{
|
|
get { return Marshal.PtrToStringAnsi(Natives.soundio_version_string()); }
|
|
}
|
|
|
|
public static int VersionMajor
|
|
{
|
|
get { return Natives.soundio_version_major(); }
|
|
}
|
|
|
|
public static int VersionMinor
|
|
{
|
|
get { return Natives.soundio_version_minor(); }
|
|
}
|
|
|
|
public static int VersionPatch
|
|
{
|
|
get { return Natives.soundio_version_patch(); }
|
|
}
|
|
|
|
public static string GetBackendName(SoundIOBackend backend)
|
|
{
|
|
return Marshal.PtrToStringAnsi(Natives.soundio_backend_name((SoundIoBackend)backend));
|
|
}
|
|
|
|
public static bool HaveBackend(SoundIOBackend backend)
|
|
{
|
|
return Natives.soundio_have_backend((SoundIoBackend)backend);
|
|
}
|
|
|
|
public static int GetBytesPerSample(SoundIOFormat format)
|
|
{
|
|
return Natives.soundio_get_bytes_per_sample((SoundIoFormat)format);
|
|
}
|
|
|
|
public static int GetBytesPerFrame(SoundIOFormat format, int channelCount)
|
|
{
|
|
return Natives.soundio_get_bytes_per_frame((SoundIoFormat)format, channelCount);
|
|
}
|
|
|
|
public static int GetBytesPerSecond(SoundIOFormat format, int channelCount, int sampleRate)
|
|
{
|
|
return Natives.soundio_get_bytes_per_second((SoundIoFormat)format, channelCount, sampleRate);
|
|
}
|
|
|
|
public static string GetSoundFormatName(SoundIOFormat format)
|
|
{
|
|
return Marshal.PtrToStringAnsi(Natives.soundio_format_string((SoundIoFormat)format));
|
|
}
|
|
}
|
|
} |