333 lines
7.3 KiB
C#
333 lines
7.3 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using EasingFunction = System.Func<float, float>;
|
|
|
|
namespace MoonWorks.Audio
|
|
{
|
|
public class AudioDevice : IDisposable
|
|
{
|
|
public IntPtr Handle { get; }
|
|
public byte[] Handle3D { get; }
|
|
public IntPtr MasteringVoice { get; }
|
|
public FAudio.FAudioDeviceDetails DeviceDetails { get; }
|
|
|
|
public float CurveDistanceScalar = 1f;
|
|
public float DopplerScale = 1f;
|
|
public float SpeedOfSound = 343.5f;
|
|
|
|
private float masteringVolume = 1f;
|
|
public float MasteringVolume
|
|
{
|
|
get => masteringVolume;
|
|
set
|
|
{
|
|
masteringVolume = value;
|
|
FAudio.FAudioVoice_SetVolume(MasteringVoice, masteringVolume, 0);
|
|
}
|
|
}
|
|
|
|
private readonly List<WeakReference<AudioResource>> resources = new List<WeakReference<AudioResource>>();
|
|
private readonly List<StreamingSound> streamingSounds = new List<StreamingSound>();
|
|
|
|
private AudioTweenPool AudioTweenPool = new AudioTweenPool();
|
|
private readonly List<AudioTween> AudioTweens = new List<AudioTween>();
|
|
|
|
private const int Step = 200;
|
|
private TimeSpan UpdateInterval;
|
|
private System.Diagnostics.Stopwatch TickStopwatch = new System.Diagnostics.Stopwatch();
|
|
private long previousTickTime;
|
|
private Thread Thread;
|
|
private AutoResetEvent WakeSignal;
|
|
internal readonly object StateLock = new object();
|
|
|
|
private bool IsDisposed;
|
|
|
|
public unsafe AudioDevice()
|
|
{
|
|
UpdateInterval = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / Step);
|
|
|
|
FAudio.FAudioCreate(out var handle, 0, FAudio.FAUDIO_DEFAULT_PROCESSOR);
|
|
Handle = handle;
|
|
|
|
/* Find a suitable device */
|
|
|
|
FAudio.FAudio_GetDeviceCount(Handle, out var devices);
|
|
|
|
if (devices == 0)
|
|
{
|
|
Logger.LogError("No audio devices found!");
|
|
FAudio.FAudio_Release(Handle);
|
|
Handle = IntPtr.Zero;
|
|
return;
|
|
}
|
|
|
|
FAudio.FAudioDeviceDetails deviceDetails;
|
|
|
|
uint i = 0;
|
|
for (i = 0; i < devices; i++)
|
|
{
|
|
FAudio.FAudio_GetDeviceDetails(
|
|
Handle,
|
|
i,
|
|
out deviceDetails
|
|
);
|
|
if ((deviceDetails.Role & FAudio.FAudioDeviceRole.FAudioDefaultGameDevice) == FAudio.FAudioDeviceRole.FAudioDefaultGameDevice)
|
|
{
|
|
DeviceDetails = deviceDetails;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == devices)
|
|
{
|
|
i = 0; /* whatever we'll just use the first one I guess */
|
|
FAudio.FAudio_GetDeviceDetails(
|
|
Handle,
|
|
i,
|
|
out deviceDetails
|
|
);
|
|
DeviceDetails = deviceDetails;
|
|
}
|
|
|
|
/* Init Mastering Voice */
|
|
IntPtr masteringVoice;
|
|
|
|
if (FAudio.FAudio_CreateMasteringVoice(
|
|
Handle,
|
|
out masteringVoice,
|
|
FAudio.FAUDIO_DEFAULT_CHANNELS,
|
|
FAudio.FAUDIO_DEFAULT_SAMPLERATE,
|
|
0,
|
|
i,
|
|
IntPtr.Zero
|
|
) != 0)
|
|
{
|
|
Logger.LogError("No mastering voice found!");
|
|
Handle = IntPtr.Zero;
|
|
FAudio.FAudio_Release(Handle);
|
|
return;
|
|
}
|
|
|
|
MasteringVoice = masteringVoice;
|
|
|
|
/* Init 3D Audio */
|
|
|
|
Handle3D = new byte[FAudio.F3DAUDIO_HANDLE_BYTESIZE];
|
|
FAudio.F3DAudioInitialize(
|
|
DeviceDetails.OutputFormat.dwChannelMask,
|
|
SpeedOfSound,
|
|
Handle3D
|
|
);
|
|
|
|
Logger.LogInfo("Setting up audio thread...");
|
|
WakeSignal = new AutoResetEvent(true);
|
|
|
|
Thread = new Thread(ThreadMain);
|
|
Thread.IsBackground = true;
|
|
Thread.Start();
|
|
|
|
TickStopwatch.Start();
|
|
previousTickTime = 0;
|
|
}
|
|
|
|
private void ThreadMain()
|
|
{
|
|
while (!IsDisposed)
|
|
{
|
|
lock (StateLock)
|
|
{
|
|
ThreadMainTick();
|
|
}
|
|
|
|
WakeSignal.WaitOne(UpdateInterval);
|
|
}
|
|
}
|
|
|
|
private void ThreadMainTick()
|
|
{
|
|
long tickDelta = TickStopwatch.Elapsed.Ticks - previousTickTime;
|
|
previousTickTime = TickStopwatch.Elapsed.Ticks;
|
|
float elapsedSeconds = (float) tickDelta / System.TimeSpan.TicksPerSecond;
|
|
|
|
for (var i = streamingSounds.Count - 1; i >= 0; i--)
|
|
{
|
|
streamingSounds[i].Update();
|
|
}
|
|
|
|
for (var i = AudioTweens.Count - 1; i >= 0; i--)
|
|
{
|
|
bool finished = true;
|
|
var audioTween = AudioTweens[i];
|
|
|
|
if (audioTween.SoundInstanceReference.TryGetTarget(out var soundInstance))
|
|
{
|
|
finished = UpdateAudioTween(audioTween, soundInstance, elapsedSeconds);
|
|
}
|
|
|
|
if (finished)
|
|
{
|
|
AudioTweenPool.Free(audioTween);
|
|
AudioTweens.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SyncPlay()
|
|
{
|
|
FAudio.FAudio_CommitChanges(Handle, 1);
|
|
}
|
|
|
|
internal void CreateTween(
|
|
SoundInstance soundInstance,
|
|
AudioTweenProperty property,
|
|
EasingFunction easingFunction,
|
|
float start,
|
|
float end,
|
|
float duration
|
|
) {
|
|
var tween = AudioTweenPool.Obtain();
|
|
tween.SoundInstanceReference = new WeakReference<SoundInstance>(soundInstance);
|
|
tween.Property = property;
|
|
tween.EasingFunction = easingFunction;
|
|
tween.Start = start;
|
|
tween.End = end;
|
|
tween.Duration = duration;
|
|
tween.Time = 0;
|
|
|
|
lock (StateLock)
|
|
{
|
|
AudioTweens.Add(tween);
|
|
}
|
|
}
|
|
|
|
private bool UpdateAudioTween(AudioTween audioTween, SoundInstance soundInstance, float delta)
|
|
{
|
|
float value;
|
|
audioTween.Time += delta;
|
|
|
|
if (audioTween.Time > audioTween.Duration)
|
|
{
|
|
value = audioTween.End;
|
|
}
|
|
else
|
|
{
|
|
value = MoonWorks.Math.Easing.Interp(
|
|
audioTween.Start,
|
|
audioTween.End,
|
|
audioTween.Time,
|
|
audioTween.Duration,
|
|
audioTween.EasingFunction
|
|
);
|
|
}
|
|
|
|
switch (audioTween.Property)
|
|
{
|
|
case AudioTweenProperty.Pan:
|
|
soundInstance.Pan = value;
|
|
break;
|
|
|
|
case AudioTweenProperty.Pitch:
|
|
soundInstance.Pitch = value;
|
|
break;
|
|
|
|
case AudioTweenProperty.Volume:
|
|
soundInstance.Volume = value;
|
|
break;
|
|
|
|
case AudioTweenProperty.FilterFrequency:
|
|
soundInstance.FilterFrequency = value;
|
|
break;
|
|
|
|
case AudioTweenProperty.Reverb:
|
|
soundInstance.Reverb = value;
|
|
break;
|
|
}
|
|
|
|
return audioTween.Time > audioTween.Duration;
|
|
}
|
|
|
|
internal void WakeThread()
|
|
{
|
|
WakeSignal.Set();
|
|
}
|
|
|
|
private void AddDynamicSoundInstance(StreamingSound instance)
|
|
{
|
|
streamingSounds.Add(instance);
|
|
}
|
|
|
|
private void RemoveDynamicSoundInstance(StreamingSound reference)
|
|
{
|
|
streamingSounds.Remove(reference);
|
|
}
|
|
|
|
internal void AddResourceReference(AudioResource resource, WeakReference<AudioResource> resourceReference)
|
|
{
|
|
lock (StateLock)
|
|
{
|
|
resources.Add(resourceReference);
|
|
|
|
if (resource is StreamingSound streamingSound)
|
|
{
|
|
AddDynamicSoundInstance(streamingSound);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RemoveResourceReference(AudioResource resource, WeakReference<AudioResource> resourceReference)
|
|
{
|
|
lock (StateLock)
|
|
{
|
|
resources.Remove(resourceReference);
|
|
|
|
if (resource is StreamingSound streamingSound)
|
|
{
|
|
RemoveDynamicSoundInstance(streamingSound);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!IsDisposed)
|
|
{
|
|
lock (StateLock)
|
|
{
|
|
if (disposing)
|
|
{
|
|
for (var i = resources.Count - 1; i >= 0; i--)
|
|
{
|
|
var weakReference = resources[i];
|
|
|
|
if (weakReference.TryGetTarget(out var resource))
|
|
{
|
|
resource.Dispose();
|
|
}
|
|
}
|
|
resources.Clear();
|
|
}
|
|
|
|
FAudio.FAudioVoice_DestroyVoice(MasteringVoice);
|
|
FAudio.FAudio_Release(Handle);
|
|
|
|
IsDisposed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
~AudioDevice()
|
|
{
|
|
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
Dispose(disposing: false);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
Dispose(disposing: true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
}
|