mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 14:18:44 +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
332 lines
11 KiB
C#
332 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace SoundIOSharp
|
|
{
|
|
public class SoundIOOutStream : IDisposable
|
|
{
|
|
internal SoundIOOutStream (Pointer<SoundIoOutStream> handle)
|
|
{
|
|
this.handle = handle;
|
|
}
|
|
|
|
Pointer<SoundIoOutStream> handle;
|
|
|
|
public void Dispose ()
|
|
{
|
|
Natives.soundio_outstream_destroy (handle);
|
|
}
|
|
// Equality (based on handle)
|
|
|
|
public override bool Equals (object other)
|
|
{
|
|
var d = other as SoundIOOutStream;
|
|
|
|
return d != null && (this.handle == d.handle);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return (int)(IntPtr)handle;
|
|
}
|
|
|
|
public static bool operator == (SoundIOOutStream obj1, SoundIOOutStream obj2)
|
|
{
|
|
return obj1 is null ? obj2 is null : obj1.Equals(obj2);
|
|
}
|
|
|
|
public static bool operator != (SoundIOOutStream obj1, SoundIOOutStream obj2)
|
|
{
|
|
return obj1 is null ? obj2 is object : !obj1.Equals(obj2);
|
|
}
|
|
|
|
// fields
|
|
|
|
public SoundIODevice Device
|
|
{
|
|
get { return new SoundIODevice(Marshal.ReadIntPtr(handle, device_offset)); }
|
|
}
|
|
|
|
static readonly int device_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("device");
|
|
|
|
public SoundIOFormat Format
|
|
{
|
|
get { return (SoundIOFormat) Marshal.ReadInt32(handle, format_offset); }
|
|
set { Marshal.WriteInt32(handle, format_offset, (int) value); }
|
|
}
|
|
|
|
static readonly int format_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("format");
|
|
|
|
public int SampleRate
|
|
{
|
|
get { return Marshal.ReadInt32(handle, sample_rate_offset); }
|
|
set { Marshal.WriteInt32(handle, sample_rate_offset, value); }
|
|
}
|
|
|
|
static readonly int sample_rate_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("sample_rate");
|
|
|
|
public SoundIOChannelLayout Layout
|
|
{
|
|
get { unsafe { return new SoundIOChannelLayout((IntPtr) (void*)((IntPtr)handle + layout_offset)); } }
|
|
set
|
|
{
|
|
unsafe
|
|
{
|
|
Buffer.MemoryCopy((void*)value.Handle, (void*)((IntPtr)handle + layout_offset), Marshal.SizeOf<SoundIoChannelLayout>(), Marshal.SizeOf<SoundIoChannelLayout>());
|
|
}
|
|
}
|
|
}
|
|
static readonly int layout_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("layout");
|
|
|
|
public double SoftwareLatency
|
|
{
|
|
get { return MarshalEx.ReadDouble (handle, software_latency_offset); }
|
|
set { MarshalEx.WriteDouble (handle, software_latency_offset, value); }
|
|
}
|
|
|
|
static readonly int software_latency_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("software_latency");
|
|
|
|
public float Volume
|
|
{
|
|
get { return MarshalEx.ReadFloat(handle, volume_offset); }
|
|
set { MarshalEx.WriteFloat(handle, volume_offset, value); }
|
|
}
|
|
|
|
static readonly int volume_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("volume");
|
|
|
|
// error_callback
|
|
public Action ErrorCallback
|
|
{
|
|
get { return error_callback; }
|
|
set
|
|
{
|
|
error_callback = value;
|
|
if (value == null)
|
|
{
|
|
error_callback_native = null;
|
|
}
|
|
else
|
|
{
|
|
error_callback_native = stream => error_callback();
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate(error_callback_native);
|
|
Marshal.WriteIntPtr(handle, error_callback_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int error_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("error_callback");
|
|
|
|
Action error_callback;
|
|
delegate void error_callback_delegate (IntPtr handle);
|
|
error_callback_delegate error_callback_native;
|
|
|
|
// write_callback
|
|
public Action<int, int> WriteCallback
|
|
{
|
|
get { return write_callback; }
|
|
set
|
|
{
|
|
write_callback = value;
|
|
if (value == null)
|
|
{
|
|
write_callback_native = null;
|
|
}
|
|
else
|
|
{
|
|
write_callback_native = (h, frame_count_min, frame_count_max) => write_callback(frame_count_min, frame_count_max);
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate (write_callback_native);
|
|
Marshal.WriteIntPtr (handle, write_callback_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int write_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("write_callback");
|
|
|
|
Action<int, int> write_callback;
|
|
delegate void write_callback_delegate(IntPtr handle, int min, int max);
|
|
write_callback_delegate write_callback_native;
|
|
|
|
// underflow_callback
|
|
public Action UnderflowCallback
|
|
{
|
|
get { return underflow_callback; }
|
|
set
|
|
{
|
|
underflow_callback = value;
|
|
if (value == null)
|
|
{
|
|
underflow_callback_native = null;
|
|
}
|
|
else
|
|
{
|
|
underflow_callback_native = h => underflow_callback();
|
|
}
|
|
|
|
var ptr = Marshal.GetFunctionPointerForDelegate (underflow_callback_native);
|
|
Marshal.WriteIntPtr (handle, underflow_callback_offset, ptr);
|
|
}
|
|
}
|
|
|
|
static readonly int underflow_callback_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("underflow_callback");
|
|
|
|
Action underflow_callback;
|
|
delegate void underflow_callback_delegate(IntPtr handle);
|
|
underflow_callback_delegate underflow_callback_native;
|
|
|
|
// FIXME: this should be taken care in more centralized/decent manner... we don't want to write
|
|
// this kind of code anywhere we need string marshaling.
|
|
List<IntPtr> allocated_hglobals = new List<IntPtr>();
|
|
|
|
public string Name {
|
|
get { return Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(handle, name_offset)); }
|
|
set
|
|
{
|
|
unsafe
|
|
{
|
|
var existing = Marshal.ReadIntPtr(handle, name_offset);
|
|
if (allocated_hglobals.Contains(existing))
|
|
{
|
|
allocated_hglobals.Remove(existing);
|
|
Marshal.FreeHGlobal(existing);
|
|
}
|
|
|
|
var ptr = Marshal.StringToHGlobalAnsi(value);
|
|
Marshal.WriteIntPtr(handle, name_offset, ptr);
|
|
allocated_hglobals.Add(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
static readonly int name_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("name");
|
|
|
|
public bool NonTerminalHint
|
|
{
|
|
get { return Marshal.ReadInt32(handle, non_terminal_hint_offset) != 0; }
|
|
}
|
|
|
|
static readonly int non_terminal_hint_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("non_terminal_hint");
|
|
|
|
public int BytesPerFrame
|
|
{
|
|
get { return Marshal.ReadInt32(handle, bytes_per_frame_offset); }
|
|
}
|
|
|
|
static readonly int bytes_per_frame_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("bytes_per_frame");
|
|
|
|
public int BytesPerSample
|
|
{
|
|
get { return Marshal.ReadInt32(handle, bytes_per_sample_offset); }
|
|
}
|
|
|
|
static readonly int bytes_per_sample_offset = (int)Marshal.OffsetOf<SoundIoOutStream>("bytes_per_sample");
|
|
|
|
public string LayoutErrorMessage
|
|
{
|
|
get
|
|
{
|
|
var code = (SoundIoError)Marshal.ReadInt32(handle, layout_error_offset);
|
|
|
|
return code == SoundIoError.SoundIoErrorNone ? null : Marshal.PtrToStringAnsi(Natives.soundio_strerror((int)code));
|
|
}
|
|
}
|
|
|
|
static readonly int layout_error_offset = (int)Marshal.OffsetOf<SoundIoOutStream> ("layout_error");
|
|
|
|
// functions
|
|
|
|
public void Open ()
|
|
{
|
|
var ret = (SoundIoError)Natives.soundio_outstream_open(handle);
|
|
if (ret != SoundIoError.SoundIoErrorNone)
|
|
{
|
|
throw new SoundIOException(ret);
|
|
}
|
|
}
|
|
|
|
public void Start ()
|
|
{
|
|
var ret = (SoundIoError)Natives.soundio_outstream_start(handle);
|
|
if (ret != SoundIoError.SoundIoErrorNone)
|
|
{
|
|
throw new SoundIOException(ret);
|
|
}
|
|
}
|
|
|
|
public SoundIOChannelAreas BeginWrite(ref int frameCount)
|
|
{
|
|
IntPtr ptrs = default;
|
|
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;
|
|
}
|
|
}
|
|
|
|
public void SetVolume (double volume)
|
|
{
|
|
var ret = (SoundIoError)Natives.soundio_outstream_set_volume(handle, volume);
|
|
if (ret != SoundIoError.SoundIoErrorNone)
|
|
{
|
|
throw new SoundIOException(ret);
|
|
}
|
|
}
|
|
}
|
|
}
|