447 lines
11 KiB
C#
447 lines
11 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using EasingFunction = System.Func<float, float>;
|
|
|
|
namespace MoonWorks.Audio
|
|
{
|
|
public abstract class Voice : AudioResource
|
|
{
|
|
protected IntPtr Handle;
|
|
|
|
protected FAudio.F3DAUDIO_DSP_SETTINGS dspSettings;
|
|
|
|
private ReverbEffect ReverbEffect;
|
|
|
|
public bool Is3D { get; protected set; }
|
|
|
|
private float pan = 0;
|
|
public virtual float Pan
|
|
{
|
|
get => pan;
|
|
internal set
|
|
{
|
|
value = Math.MathHelper.Clamp(value, -1f, 1f);
|
|
if (pan != value)
|
|
{
|
|
pan = value;
|
|
|
|
if (pan < -1f)
|
|
{
|
|
pan = -1f;
|
|
}
|
|
if (pan > 1f)
|
|
{
|
|
pan = 1f;
|
|
}
|
|
|
|
if (Is3D) { return; }
|
|
|
|
SetPanMatrixCoefficients();
|
|
FAudio.FAudioVoice_SetOutputMatrix(
|
|
Handle,
|
|
Device.MasteringVoice.Handle,
|
|
dspSettings.SrcChannelCount,
|
|
dspSettings.DstChannelCount,
|
|
dspSettings.pMatrixCoefficients,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private float pitch = 0;
|
|
public float Pitch
|
|
{
|
|
get => pitch;
|
|
internal set
|
|
{
|
|
value = Math.MathHelper.Clamp(value, -1f, 1f);
|
|
if (pitch != value)
|
|
{
|
|
pitch = value;
|
|
UpdatePitch();
|
|
}
|
|
}
|
|
}
|
|
|
|
private float volume = 1;
|
|
public float Volume
|
|
{
|
|
get => volume;
|
|
internal set
|
|
{
|
|
value = Math.MathHelper.Max(0, value);
|
|
if (volume != value)
|
|
{
|
|
volume = value;
|
|
FAudio.FAudioVoice_SetVolume(Handle, volume, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
private const float MAX_FILTER_FREQUENCY = 1f;
|
|
private const float MAX_FILTER_ONEOVERQ = 1.5f;
|
|
|
|
private FAudio.FAudioFilterParameters filterParameters = new FAudio.FAudioFilterParameters
|
|
{
|
|
Type = FAudio.FAudioFilterType.FAudioLowPassFilter,
|
|
Frequency = 1f,
|
|
OneOverQ = 1f
|
|
};
|
|
|
|
public float FilterFrequency
|
|
{
|
|
get => filterParameters.Frequency;
|
|
internal set
|
|
{
|
|
value = System.Math.Clamp(value, 0.01f, MAX_FILTER_FREQUENCY);
|
|
if (filterParameters.Frequency != value)
|
|
{
|
|
filterParameters.Frequency = value;
|
|
|
|
FAudio.FAudioVoice_SetFilterParameters(
|
|
Handle,
|
|
ref filterParameters,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
public float FilterOneOverQ
|
|
{
|
|
get => filterParameters.OneOverQ;
|
|
internal set
|
|
{
|
|
value = System.Math.Clamp(value, 0.01f, MAX_FILTER_ONEOVERQ);
|
|
if (filterParameters.OneOverQ != value)
|
|
{
|
|
filterParameters.OneOverQ = value;
|
|
|
|
FAudio.FAudioVoice_SetFilterParameters(
|
|
Handle,
|
|
ref filterParameters,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private FilterType filterType;
|
|
public FilterType FilterType
|
|
{
|
|
get => filterType;
|
|
set
|
|
{
|
|
if (filterType != value)
|
|
{
|
|
filterType = value;
|
|
|
|
switch (filterType)
|
|
{
|
|
case FilterType.None:
|
|
filterParameters = new FAudio.FAudioFilterParameters
|
|
{
|
|
Type = FAudio.FAudioFilterType.FAudioLowPassFilter,
|
|
Frequency = 1f,
|
|
OneOverQ = 1f
|
|
};
|
|
break;
|
|
|
|
case FilterType.LowPass:
|
|
filterParameters.Type = FAudio.FAudioFilterType.FAudioLowPassFilter;
|
|
filterParameters.Frequency = 1f;
|
|
break;
|
|
|
|
case FilterType.BandPass:
|
|
filterParameters.Type = FAudio.FAudioFilterType.FAudioBandPassFilter;
|
|
break;
|
|
|
|
case FilterType.HighPass:
|
|
filterParameters.Type = FAudio.FAudioFilterType.FAudioHighPassFilter;
|
|
filterParameters.Frequency = 0f;
|
|
break;
|
|
}
|
|
|
|
FAudio.FAudioVoice_SetFilterParameters(
|
|
Handle,
|
|
ref filterParameters,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private float reverb;
|
|
public unsafe float Reverb
|
|
{
|
|
get => reverb;
|
|
internal set
|
|
{
|
|
if (ReverbEffect != null)
|
|
{
|
|
value = MathF.Max(0, value);
|
|
if (reverb != value)
|
|
{
|
|
reverb = value;
|
|
|
|
float* outputMatrix = (float*) dspSettings.pMatrixCoefficients;
|
|
outputMatrix[0] = reverb;
|
|
if (dspSettings.SrcChannelCount == 2)
|
|
{
|
|
outputMatrix[1] = reverb;
|
|
}
|
|
|
|
FAudio.FAudioVoice_SetOutputMatrix(
|
|
Handle,
|
|
ReverbEffect.Handle,
|
|
dspSettings.SrcChannelCount,
|
|
1,
|
|
dspSettings.pMatrixCoefficients,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
if (ReverbEffect == null)
|
|
{
|
|
Logger.LogWarn("Tried to set reverb value before applying a reverb effect");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public Voice(AudioDevice device) : base(device) { }
|
|
|
|
public void SetPan(float targetValue)
|
|
{
|
|
Pan = targetValue;
|
|
Device.ClearTweens(this, AudioTweenProperty.Pan);
|
|
}
|
|
|
|
public void SetPan(float targetValue, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Pan, easingFunction, Pan, targetValue, duration, 0);
|
|
}
|
|
|
|
public void SetPan(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Pan, easingFunction, Pan, targetValue, duration, delayTime);
|
|
}
|
|
|
|
public void SetPitch(float targetValue)
|
|
{
|
|
Pitch = targetValue;
|
|
Device.ClearTweens(this, AudioTweenProperty.Pitch);
|
|
}
|
|
|
|
public void SetPitch(float targetValue, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Pitch, easingFunction, Pitch, targetValue, duration, 0);
|
|
}
|
|
|
|
public void SetPitch(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Pitch, easingFunction, Pitch, targetValue, duration, delayTime);
|
|
}
|
|
|
|
public void SetVolume(float targetValue)
|
|
{
|
|
Volume = targetValue;
|
|
Device.ClearTweens(this, AudioTweenProperty.Volume);
|
|
}
|
|
|
|
public void SetVolume(float targetValue, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Volume, easingFunction, Volume, targetValue, duration, 0);
|
|
}
|
|
|
|
public void SetVolume(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Volume, easingFunction, Volume, targetValue, duration, delayTime);
|
|
}
|
|
|
|
public void SetFilterFrequency(float targetValue)
|
|
{
|
|
FilterFrequency = targetValue;
|
|
Device.ClearTweens(this, AudioTweenProperty.FilterFrequency);
|
|
}
|
|
|
|
public void SetFilterFrequency(float targetValue, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.FilterFrequency, easingFunction, FilterFrequency, targetValue, duration, 0);
|
|
}
|
|
|
|
public void SetFilterFrequency(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.FilterFrequency, easingFunction, FilterFrequency, targetValue, duration, delayTime);
|
|
}
|
|
|
|
public void SetFilterOneOverQ(float targetValue)
|
|
{
|
|
FilterOneOverQ = targetValue;
|
|
}
|
|
|
|
public void SetReverb(float targetValue)
|
|
{
|
|
Reverb = targetValue;
|
|
Device.ClearTweens(this, AudioTweenProperty.Reverb);
|
|
}
|
|
|
|
public void SetReverb(float targetValue, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Reverb, easingFunction, Volume, targetValue, duration, 0);
|
|
}
|
|
|
|
public void SetReverb(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
|
|
{
|
|
Device.CreateTween(this, AudioTweenProperty.Reverb, easingFunction, Volume, targetValue, duration, delayTime);
|
|
}
|
|
|
|
public unsafe void SetSends(Voice send)
|
|
{
|
|
FAudio.FAudioSendDescriptor* sendDesc = stackalloc FAudio.FAudioSendDescriptor[1];
|
|
sendDesc[0].Flags = 0;
|
|
sendDesc[0].pOutputVoice = send.Handle;
|
|
|
|
var sends = new FAudio.FAudioVoiceSends();
|
|
sends.SendCount = 1;
|
|
sends.pSends = (nint) sendDesc;
|
|
|
|
FAudio.FAudioVoice_SetOutputVoices(
|
|
Handle,
|
|
ref sends
|
|
);
|
|
}
|
|
|
|
public unsafe void SetSends(Voice sendOne, Voice sendTwo)
|
|
{
|
|
var sendDesc = stackalloc FAudio.FAudioSendDescriptor[2];
|
|
sendDesc[0].Flags = 0;
|
|
sendDesc[0].pOutputVoice = sendOne.Handle;
|
|
sendDesc[1].Flags = 0;
|
|
sendDesc[1].pOutputVoice = sendTwo.Handle;
|
|
|
|
var sends = new FAudio.FAudioVoiceSends();
|
|
sends.SendCount = 2;
|
|
sends.pSends = (nint) sendDesc;
|
|
|
|
FAudio.FAudioVoice_SetOutputVoices(
|
|
Handle,
|
|
ref sends
|
|
);
|
|
}
|
|
|
|
public unsafe void SetReverbEffectChain(ReverbEffect reverbEffect)
|
|
{
|
|
SetSends(Device.MasteringVoice, reverbEffect);
|
|
ReverbEffect = reverbEffect;
|
|
}
|
|
|
|
private unsafe void InitDSPSettings(uint srcChannels)
|
|
{
|
|
dspSettings = new FAudio.F3DAUDIO_DSP_SETTINGS();
|
|
dspSettings.DopplerFactor = 1f;
|
|
dspSettings.SrcChannelCount = srcChannels;
|
|
dspSettings.DstChannelCount = Device.DeviceDetails.OutputFormat.Format.nChannels;
|
|
|
|
nuint memsize = (
|
|
4 *
|
|
dspSettings.SrcChannelCount *
|
|
dspSettings.DstChannelCount
|
|
);
|
|
|
|
dspSettings.pMatrixCoefficients = (nint) NativeMemory.Alloc(memsize);
|
|
byte* memPtr = (byte*) dspSettings.pMatrixCoefficients;
|
|
for (uint i = 0; i < memsize; i += 1)
|
|
{
|
|
memPtr[i] = 0;
|
|
}
|
|
|
|
SetPanMatrixCoefficients();
|
|
}
|
|
|
|
private void UpdatePitch()
|
|
{
|
|
float doppler;
|
|
float dopplerScale = Device.DopplerScale;
|
|
if (!Is3D || dopplerScale == 0.0f)
|
|
{
|
|
doppler = 1.0f;
|
|
}
|
|
else
|
|
{
|
|
doppler = dspSettings.DopplerFactor * dopplerScale;
|
|
}
|
|
|
|
FAudio.FAudioSourceVoice_SetFrequencyRatio(
|
|
Handle,
|
|
(float) System.Math.Pow(2.0, pitch) * doppler,
|
|
0
|
|
);
|
|
}
|
|
|
|
// Taken from https://github.com/FNA-XNA/FNA/blob/master/src/Audio/SoundEffectInstance.cs
|
|
private unsafe void SetPanMatrixCoefficients()
|
|
{
|
|
/* Two major things to notice:
|
|
* 1. The spec assumes any speaker count >= 2 has Front Left/Right.
|
|
* 2. Stereo panning is WAY more complicated than you think.
|
|
* The main thing is that hard panning does NOT eliminate an
|
|
* entire channel; the two channels are blended on each side.
|
|
* -flibit
|
|
*/
|
|
float* outputMatrix = (float*) dspSettings.pMatrixCoefficients;
|
|
if (dspSettings.SrcChannelCount == 1)
|
|
{
|
|
if (dspSettings.DstChannelCount == 1)
|
|
{
|
|
outputMatrix[0] = 1.0f;
|
|
}
|
|
else
|
|
{
|
|
outputMatrix[0] = (pan > 0.0f) ? (1.0f - pan) : 1.0f;
|
|
outputMatrix[1] = (pan < 0.0f) ? (1.0f + pan) : 1.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dspSettings.DstChannelCount == 1)
|
|
{
|
|
outputMatrix[0] = 1.0f;
|
|
outputMatrix[1] = 1.0f;
|
|
}
|
|
else
|
|
{
|
|
if (pan <= 0.0f)
|
|
{
|
|
// Left speaker blends left/right channels
|
|
outputMatrix[0] = 0.5f * pan + 1.0f;
|
|
outputMatrix[1] = 0.5f * -pan;
|
|
// Right speaker gets less of the right channel
|
|
outputMatrix[2] = 0.0f;
|
|
outputMatrix[3] = pan + 1.0f;
|
|
}
|
|
else
|
|
{
|
|
// Left speaker gets less of the left channel
|
|
outputMatrix[0] = -pan + 1.0f;
|
|
outputMatrix[1] = 0.0f;
|
|
// Right speaker blends right/left channels
|
|
outputMatrix[2] = 0.5f * pan;
|
|
outputMatrix[3] = 0.5f * -pan + 1.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected unsafe override void Destroy()
|
|
{
|
|
FAudio.FAudioVoice_DestroyVoice(Handle);
|
|
|
|
NativeMemory.Free((void*) dspSettings.pMatrixCoefficients);
|
|
}
|
|
}
|
|
}
|