mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 07:38:42 +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
267 lines
10 KiB
C#
267 lines
10 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace SoundIOSharp
|
|
{
|
|
public class SoundIODevice
|
|
{
|
|
public static SoundIOChannelLayout BestMatchingChannelLayout(SoundIODevice device1, SoundIODevice device2)
|
|
{
|
|
var ptr1 = Marshal.ReadIntPtr(device1.handle, layouts_offset);
|
|
var ptr2 = Marshal.ReadIntPtr(device2.handle, layouts_offset);
|
|
|
|
return new SoundIOChannelLayout(Natives.soundio_best_matching_channel_layout(ptr1, device1.LayoutCount, ptr2, device2.LayoutCount));
|
|
}
|
|
|
|
internal SoundIODevice(Pointer<SoundIoDevice> handle)
|
|
{
|
|
this.handle = handle;
|
|
}
|
|
|
|
readonly Pointer<SoundIoDevice> handle;
|
|
|
|
// Equality (based on handle and native func)
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
var d = other as SoundIODevice;
|
|
|
|
return d != null && (this.handle == d.handle || Natives.soundio_device_equal (this.handle, d.handle));
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return (int)(IntPtr)handle;
|
|
}
|
|
|
|
public static bool operator == (SoundIODevice obj1, SoundIODevice obj2)
|
|
{
|
|
return obj1 is null ? obj2 is null : obj1.Equals(obj2);
|
|
}
|
|
|
|
public static bool operator != (SoundIODevice obj1, SoundIODevice obj2)
|
|
{
|
|
return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
|
|
}
|
|
|
|
// fields
|
|
|
|
public SoundIODeviceAim Aim
|
|
{
|
|
get { return (SoundIODeviceAim)Marshal.ReadInt32(handle, aim_offset); }
|
|
}
|
|
|
|
static readonly int aim_offset = (int)Marshal.OffsetOf<SoundIoDevice>("aim");
|
|
|
|
public SoundIOFormat CurrentFormat
|
|
{
|
|
get { return (SoundIOFormat)Marshal.ReadInt32(handle, current_format_offset); }
|
|
}
|
|
|
|
static readonly int current_format_offset = (int)Marshal.OffsetOf<SoundIoDevice>("current_format");
|
|
|
|
public SoundIOChannelLayout CurrentLayout
|
|
{
|
|
get { return new SoundIOChannelLayout((IntPtr)handle + current_layout_offset); }
|
|
}
|
|
|
|
static readonly int current_layout_offset = (int)Marshal.OffsetOf<SoundIoDevice>("current_layout");
|
|
|
|
public int FormatCount
|
|
{
|
|
get { return Marshal.ReadInt32(handle, format_count_offset); }
|
|
}
|
|
|
|
static readonly int format_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("format_count");
|
|
|
|
public IEnumerable<SoundIOFormat> Formats
|
|
{
|
|
get
|
|
{
|
|
var ptr = Marshal.ReadIntPtr(handle, formats_offset);
|
|
|
|
for (int i = 0; i < FormatCount; i++)
|
|
{
|
|
yield return (SoundIOFormat)Marshal.ReadInt32(ptr, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static readonly int formats_offset = (int)Marshal.OffsetOf<SoundIoDevice>("formats");
|
|
|
|
public string Id
|
|
{
|
|
get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, id_offset)); }
|
|
}
|
|
|
|
static readonly int id_offset = (int)Marshal.OffsetOf<SoundIoDevice>("id");
|
|
|
|
public bool IsRaw
|
|
{
|
|
get { return Marshal.ReadInt32(handle, is_raw_offset) != 0; }
|
|
}
|
|
|
|
static readonly int is_raw_offset = (int)Marshal.OffsetOf<SoundIoDevice>("is_raw");
|
|
|
|
public int LayoutCount
|
|
{
|
|
get { return Marshal.ReadInt32(handle, layout_count_offset); }
|
|
}
|
|
|
|
static readonly int layout_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("layout_count");
|
|
|
|
public IEnumerable<SoundIOChannelLayout> Layouts
|
|
{
|
|
get
|
|
{
|
|
var ptr = Marshal.ReadIntPtr (handle, layouts_offset);
|
|
|
|
for (int i = 0; i < LayoutCount; i++)
|
|
{
|
|
yield return new SoundIOChannelLayout(ptr + i * Marshal.SizeOf<SoundIoChannelLayout>());
|
|
}
|
|
}
|
|
}
|
|
|
|
static readonly int layouts_offset = (int)Marshal.OffsetOf<SoundIoDevice>("layouts");
|
|
|
|
public string Name
|
|
{
|
|
get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, name_offset)); }
|
|
}
|
|
|
|
static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoDevice>("name");
|
|
|
|
public int ProbeError
|
|
{
|
|
get { return Marshal.ReadInt32(handle, probe_error_offset); }
|
|
}
|
|
|
|
static readonly int probe_error_offset = (int)Marshal.OffsetOf<SoundIoDevice>("probe_error");
|
|
|
|
public int ReferenceCount
|
|
{
|
|
get { return Marshal.ReadInt32(handle, ref_count_offset); }
|
|
}
|
|
|
|
static readonly int ref_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("ref_count");
|
|
|
|
public int SampleRateCount
|
|
{
|
|
get { return Marshal.ReadInt32(handle, sample_rate_count_offset); }
|
|
}
|
|
|
|
static readonly int sample_rate_count_offset = (int)Marshal.OffsetOf<SoundIoDevice>("sample_rate_count");
|
|
|
|
public IEnumerable<SoundIOSampleRateRange> SampleRates
|
|
{
|
|
get
|
|
{
|
|
var ptr = Marshal.ReadIntPtr(handle, sample_rates_offset);
|
|
|
|
for (int i = 0; i < SampleRateCount; i++)
|
|
{
|
|
yield return new SoundIOSampleRateRange(Marshal.ReadInt32(ptr, i * 2), Marshal.ReadInt32(ptr, i * 2 + 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
static readonly int sample_rates_offset = (int)Marshal.OffsetOf<SoundIoDevice>("sample_rates");
|
|
|
|
public double SoftwareLatencyCurrent
|
|
{
|
|
get { return MarshalEx.ReadDouble(handle, software_latency_current_offset); }
|
|
set { MarshalEx.WriteDouble(handle, software_latency_current_offset, value); }
|
|
}
|
|
|
|
static readonly int software_latency_current_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_current");
|
|
|
|
public double SoftwareLatencyMin
|
|
{
|
|
get { return MarshalEx.ReadDouble(handle, software_latency_min_offset); }
|
|
set { MarshalEx.WriteDouble(handle, software_latency_min_offset, value); }
|
|
}
|
|
|
|
static readonly int software_latency_min_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_min");
|
|
|
|
public double SoftwareLatencyMax
|
|
{
|
|
get { return MarshalEx.ReadDouble(handle, software_latency_max_offset); }
|
|
set { MarshalEx.WriteDouble(handle, software_latency_max_offset, value); }
|
|
}
|
|
|
|
static readonly int software_latency_max_offset = (int)Marshal.OffsetOf<SoundIoDevice>("software_latency_max");
|
|
|
|
public SoundIO SoundIO
|
|
{
|
|
get { return new SoundIO(Marshal.ReadIntPtr(handle, soundio_offset)); }
|
|
}
|
|
|
|
static readonly int soundio_offset = (int)Marshal.OffsetOf<SoundIoDevice>("soundio");
|
|
|
|
// functions
|
|
|
|
public void AddReference()
|
|
{
|
|
Natives.soundio_device_ref(handle);
|
|
}
|
|
|
|
public void RemoveReference()
|
|
{
|
|
Natives.soundio_device_unref(handle);
|
|
}
|
|
|
|
public void SortDeviceChannelLayouts()
|
|
{
|
|
Natives.soundio_device_sort_channel_layouts(handle);
|
|
}
|
|
|
|
public static readonly SoundIOFormat S16NE = BitConverter.IsLittleEndian ? SoundIOFormat.S16LE : SoundIOFormat.S16BE;
|
|
public static readonly SoundIOFormat U16NE = BitConverter.IsLittleEndian ? SoundIOFormat.U16LE : SoundIOFormat.U16BE;
|
|
public static readonly SoundIOFormat S24NE = BitConverter.IsLittleEndian ? SoundIOFormat.S24LE : SoundIOFormat.S24BE;
|
|
public static readonly SoundIOFormat U24NE = BitConverter.IsLittleEndian ? SoundIOFormat.U24LE : SoundIOFormat.U24BE;
|
|
public static readonly SoundIOFormat S32NE = BitConverter.IsLittleEndian ? SoundIOFormat.S32LE : SoundIOFormat.S32BE;
|
|
public static readonly SoundIOFormat U32NE = BitConverter.IsLittleEndian ? SoundIOFormat.U32LE : SoundIOFormat.U32BE;
|
|
public static readonly SoundIOFormat Float32NE = BitConverter.IsLittleEndian ? SoundIOFormat.Float32LE : SoundIOFormat.Float32BE;
|
|
public static readonly SoundIOFormat Float64NE = BitConverter.IsLittleEndian ? SoundIOFormat.Float64LE : SoundIOFormat.Float64BE;
|
|
public static readonly SoundIOFormat S16FE = !BitConverter.IsLittleEndian ? SoundIOFormat.S16LE : SoundIOFormat.S16BE;
|
|
public static readonly SoundIOFormat U16FE = !BitConverter.IsLittleEndian ? SoundIOFormat.U16LE : SoundIOFormat.U16BE;
|
|
public static readonly SoundIOFormat S24FE = !BitConverter.IsLittleEndian ? SoundIOFormat.S24LE : SoundIOFormat.S24BE;
|
|
public static readonly SoundIOFormat U24FE = !BitConverter.IsLittleEndian ? SoundIOFormat.U24LE : SoundIOFormat.U24BE;
|
|
public static readonly SoundIOFormat S32FE = !BitConverter.IsLittleEndian ? SoundIOFormat.S32LE : SoundIOFormat.S32BE;
|
|
public static readonly SoundIOFormat U32FE = !BitConverter.IsLittleEndian ? SoundIOFormat.U32LE : SoundIOFormat.U32BE;
|
|
public static readonly SoundIOFormat Float32FE = !BitConverter.IsLittleEndian ? SoundIOFormat.Float32LE : SoundIOFormat.Float32BE;
|
|
public static readonly SoundIOFormat Float64FE = !BitConverter.IsLittleEndian ? SoundIOFormat.Float64LE : SoundIOFormat.Float64BE;
|
|
|
|
public bool SupportsFormat(SoundIOFormat format)
|
|
{
|
|
return Natives.soundio_device_supports_format(handle, (SoundIoFormat)format);
|
|
}
|
|
|
|
public bool SupportsSampleRate(int sampleRate)
|
|
{
|
|
return Natives.soundio_device_supports_sample_rate(handle, sampleRate);
|
|
}
|
|
|
|
public bool SupportsChannelCount(int channelCount)
|
|
{
|
|
return Natives.soundio_device_supports_layout(handle, SoundIOChannelLayout.GetDefault(channelCount).Handle);
|
|
}
|
|
|
|
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));
|
|
}
|
|
}
|
|
} |