MoonWorks/src/Audio/SoundInstance.cs

509 lines
12 KiB
C#
Raw Normal View History

using System;
2021-01-20 02:06:10 +00:00
using System.Runtime.InteropServices;
using EasingFunction = System.Func<float, float>;
2021-01-20 02:06:10 +00:00
namespace MoonWorks.Audio
{
2022-02-23 05:14:32 +00:00
public abstract class SoundInstance : AudioResource
{
2023-03-02 01:47:09 +00:00
internal IntPtr Voice;
private FAudio.FAudioWaveFormatEx format;
public FAudio.FAudioWaveFormatEx Format => format;
2022-02-23 05:14:32 +00:00
protected FAudio.F3DAUDIO_DSP_SETTINGS dspSettings;
2023-03-02 01:47:09 +00:00
private ReverbEffect ReverbEffect;
private FAudio.FAudioVoiceSends ReverbSends;
2022-04-07 21:19:43 +00:00
public bool Is3D { get; protected set; }
2022-02-23 05:14:32 +00:00
public virtual SoundState State { get; protected set; }
2022-02-23 05:14:32 +00:00
private float pan = 0;
2022-02-23 05:14:32 +00:00
public float Pan
{
get => pan;
internal set
2022-02-23 05:14:32 +00:00
{
value = Math.MathHelper.Clamp(value, -1f, 1f);
if (pan != value)
2022-02-23 05:14:32 +00:00
{
pan = value;
if (pan < -1f)
{
pan = -1f;
}
if (pan > 1f)
{
pan = 1f;
}
2022-02-23 05:14:32 +00:00
if (Is3D) { return; }
SetPanMatrixCoefficients();
FAudio.FAudioVoice_SetOutputMatrix(
Voice,
Device.MasteringVoice,
dspSettings.SrcChannelCount,
dspSettings.DstChannelCount,
dspSettings.pMatrixCoefficients,
0
);
}
2022-02-23 05:14:32 +00:00
}
}
private float pitch = 0;
2022-02-23 05:14:32 +00:00
public float Pitch
{
get => pitch;
internal set
2022-02-23 05:14:32 +00:00
{
value = Math.MathHelper.Clamp(value, -1f, 1f);
if (pitch != value)
{
pitch = value;
UpdatePitch();
}
2022-02-23 05:14:32 +00:00
}
}
private float volume = 1;
2022-02-23 05:14:32 +00:00
public float Volume
{
get => volume;
internal set
2022-02-23 05:14:32 +00:00
{
value = Math.MathHelper.Max(0, value);
if (volume != value)
{
volume = value;
FAudio.FAudioVoice_SetVolume(Voice, volume, 0);
}
2022-02-23 05:14:32 +00:00
}
}
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
2022-02-23 05:14:32 +00:00
{
get => filterParameters.Frequency;
internal set
2022-02-23 05:14:32 +00:00
{
value = System.Math.Clamp(value, 0.01f, MAX_FILTER_FREQUENCY);
if (filterParameters.Frequency != value)
{
filterParameters.Frequency = value;
2022-02-23 05:14:32 +00:00
FAudio.FAudioVoice_SetFilterParameters(
Voice,
ref filterParameters,
0
);
}
2022-02-23 05:14:32 +00:00
}
}
public float FilterOneOverQ
2022-02-23 05:14:32 +00:00
{
get => filterParameters.OneOverQ;
internal set
2022-02-23 05:14:32 +00:00
{
value = System.Math.Clamp(value, 0.01f, MAX_FILTER_ONEOVERQ);
if (filterParameters.OneOverQ != value)
{
filterParameters.OneOverQ = value;
2022-02-23 05:14:32 +00:00
FAudio.FAudioVoice_SetFilterParameters(
Voice,
ref filterParameters,
0
);
}
2022-02-23 05:14:32 +00:00
}
}
private FilterType filterType;
public FilterType FilterType
2022-02-23 05:14:32 +00:00
{
get => filterType;
2022-02-23 05:14:32 +00:00
set
{
if (filterType != value)
2022-02-23 05:14:32 +00:00
{
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(
Voice,
ref filterParameters,
0
);
}
2022-02-23 05:14:32 +00:00
}
}
2023-03-02 01:47:09 +00:00
private float reverb;
public unsafe float Reverb
{
get => reverb;
internal set
2023-03-02 01:47:09 +00:00
{
if (ReverbEffect != null)
{
value = MathF.Max(0, value);
if (reverb != value)
2023-03-02 01:47:09 +00:00
{
reverb = value;
2023-03-02 01:47:09 +00:00
float* outputMatrix = (float*) dspSettings.pMatrixCoefficients;
outputMatrix[0] = reverb;
if (dspSettings.SrcChannelCount == 2)
{
outputMatrix[1] = reverb;
}
FAudio.FAudioVoice_SetOutputMatrix(
Voice,
ReverbEffect.Voice,
dspSettings.SrcChannelCount,
1,
dspSettings.pMatrixCoefficients,
0
);
}
2023-03-02 01:47:09 +00:00
}
#if DEBUG
if (ReverbEffect == null)
{
Logger.LogWarn("Tried to set reverb value before applying a reverb effect");
}
#endif
}
}
public unsafe SoundInstance(
2022-02-23 05:14:32 +00:00
AudioDevice device,
ushort formatTag,
ushort bitsPerSample,
ushort blockAlign,
2022-02-23 05:14:32 +00:00
ushort channels,
2022-04-07 21:19:43 +00:00
uint samplesPerSecond
2022-02-23 05:14:32 +00:00
) : base(device)
{
format = new FAudio.FAudioWaveFormatEx
2022-02-23 05:14:32 +00:00
{
wFormatTag = formatTag,
wBitsPerSample = bitsPerSample,
2022-02-23 05:14:32 +00:00
nChannels = channels,
nBlockAlign = blockAlign,
nSamplesPerSec = samplesPerSecond,
nAvgBytesPerSec = blockAlign * samplesPerSecond
};
FAudio.FAudio_CreateSourceVoice(
Device.Handle,
2023-03-02 01:47:09 +00:00
out Voice,
ref format,
2022-02-23 05:14:32 +00:00
FAudio.FAUDIO_VOICE_USEFILTER,
FAudio.FAUDIO_DEFAULT_FREQ_RATIO,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero
);
2023-03-02 01:47:09 +00:00
if (Voice == IntPtr.Zero)
2022-02-23 05:14:32 +00:00
{
Logger.LogError("SoundInstance failed to initialize!");
return;
}
InitDSPSettings(Format.nChannels);
State = SoundState.Stopped;
}
public void Apply3D(AudioListener listener, AudioEmitter emitter)
{
2022-04-07 21:19:43 +00:00
Is3D = true;
2022-02-23 05:14:32 +00:00
emitter.emitterData.CurveDistanceScaler = Device.CurveDistanceScalar;
emitter.emitterData.ChannelCount = dspSettings.SrcChannelCount;
FAudio.F3DAudioCalculate(
Device.Handle3D,
ref listener.listenerData,
ref emitter.emitterData,
FAudio.F3DAUDIO_CALCULATE_MATRIX | FAudio.F3DAUDIO_CALCULATE_DOPPLER,
ref dspSettings
);
UpdatePitch();
FAudio.FAudioVoice_SetOutputMatrix(
2023-03-02 01:47:09 +00:00
Voice,
2022-02-23 05:14:32 +00:00
Device.MasteringVoice,
dspSettings.SrcChannelCount,
dspSettings.DstChannelCount,
dspSettings.pMatrixCoefficients,
0
);
}
2023-03-02 01:47:09 +00:00
public unsafe void ApplyReverb(ReverbEffect reverbEffect)
{
ReverbSends = new FAudio.FAudioVoiceSends();
ReverbSends.SendCount = 2;
ReverbSends.pSends = (nint) NativeMemory.Alloc((nuint) (2 * Marshal.SizeOf<FAudio.FAudioSendDescriptor>()));
FAudio.FAudioSendDescriptor* sendDesc = (FAudio.FAudioSendDescriptor*) ReverbSends.pSends;
sendDesc[0].Flags = 0;
sendDesc[0].pOutputVoice = Device.MasteringVoice;
sendDesc[1].Flags = 0;
sendDesc[1].pOutputVoice = reverbEffect.Voice;
FAudio.FAudioVoice_SetOutputVoices(
Voice,
ref ReverbSends
);
ReverbEffect = reverbEffect;
}
public void SetPan(float targetValue)
{
Pan = targetValue;
Device.ClearTweens(weakReference, 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(weakReference, AudioTweenProperty.Pitch);
}
public void SetPitch(float targetValue, float duration, EasingFunction easingFunction)
{
Device.CreateTween(this, AudioTweenProperty.Pitch, easingFunction, Pan, targetValue, duration, 0);
}
public void SetPitch(float targetValue, float delayTime, float duration, EasingFunction easingFunction)
{
Device.CreateTween(this, AudioTweenProperty.Pitch, easingFunction, Pan, targetValue, duration, delayTime);
}
public void SetVolume(float targetValue)
{
Volume = targetValue;
Device.ClearTweens(weakReference, 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(weakReference, 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(weakReference, 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 abstract void Play();
public abstract void QueueSyncPlay();
2022-02-23 05:14:32 +00:00
public abstract void Pause();
public abstract void Stop();
public abstract void StopImmediate();
2022-02-23 05:14:32 +00:00
2023-03-02 01:47:09 +00:00
private unsafe void InitDSPSettings(uint srcChannels)
2022-02-23 05:14:32 +00:00
{
dspSettings = new FAudio.F3DAUDIO_DSP_SETTINGS();
dspSettings.DopplerFactor = 1f;
dspSettings.SrcChannelCount = srcChannels;
dspSettings.DstChannelCount = Device.DeviceDetails.OutputFormat.Format.nChannels;
2023-03-02 01:47:09 +00:00
nuint memsize = (
2022-02-23 05:14:32 +00:00
4 *
2023-03-02 01:47:09 +00:00
dspSettings.SrcChannelCount *
dspSettings.DstChannelCount
2022-02-23 05:14:32 +00:00
);
2023-03-02 01:47:09 +00:00
dspSettings.pMatrixCoefficients = (nint) NativeMemory.Alloc(memsize);
byte* memPtr = (byte*) dspSettings.pMatrixCoefficients;
for (uint i = 0; i < memsize; i += 1)
2022-02-23 05:14:32 +00:00
{
memPtr[i] = 0;
2022-02-23 05:14:32 +00:00
}
2022-02-23 05:14:32 +00:00
SetPanMatrixCoefficients();
}
2021-01-20 02:06:10 +00:00
2021-02-27 00:17:26 +00:00
private void UpdatePitch()
{
float doppler;
float dopplerScale = Device.DopplerScale;
2022-04-07 21:19:43 +00:00
if (!Is3D || dopplerScale == 0.0f)
2021-02-27 00:17:26 +00:00
{
doppler = 1.0f;
}
else
{
doppler = dspSettings.DopplerFactor * dopplerScale;
}
FAudio.FAudioSourceVoice_SetFrequencyRatio(
2023-03-02 01:47:09 +00:00
Voice,
(float) System.Math.Pow(2.0, pitch) * doppler,
2021-02-27 00:17:26 +00:00
0
);
}
2022-02-23 05:14:32 +00:00
// Taken from https://github.com/FNA-XNA/FNA/blob/master/src/Audio/SoundEffectInstance.cs
private unsafe void SetPanMatrixCoefficients()
{
/* Two major things to notice:
2021-01-20 02:06:10 +00:00
* 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;
2021-01-20 02:06:10 +00:00
}
}
else
{
if (dspSettings.DstChannelCount == 1)
{
outputMatrix[0] = 1.0f;
outputMatrix[1] = 1.0f;
}
else
{
if (pan <= 0.0f)
2021-01-20 02:06:10 +00:00
{
// Left speaker blends left/right channels
outputMatrix[0] = 0.5f * pan + 1.0f;
outputMatrix[1] = 0.5f * -pan;
2021-01-20 02:06:10 +00:00
// Right speaker gets less of the right channel
outputMatrix[2] = 0.0f;
outputMatrix[3] = pan + 1.0f;
2021-01-20 02:06:10 +00:00
}
else
{
// Left speaker gets less of the left channel
outputMatrix[0] = -pan + 1.0f;
2021-01-20 02:06:10 +00:00
outputMatrix[1] = 0.0f;
// Right speaker blends right/left channels
outputMatrix[2] = 0.5f * pan;
outputMatrix[3] = 0.5f * -pan + 1.0f;
2021-01-20 02:06:10 +00:00
}
}
}
2022-02-23 05:14:32 +00:00
}
2021-01-20 02:06:10 +00:00
2023-03-02 01:47:09 +00:00
protected unsafe override void Destroy()
2022-02-23 05:14:32 +00:00
{
StopImmediate();
2023-03-02 01:47:09 +00:00
FAudio.FAudioVoice_DestroyVoice(Voice);
NativeMemory.Free((void*) dspSettings.pMatrixCoefficients);
if (ReverbEffect != null)
{
NativeMemory.Free((void*) ReverbSends.pSends);
}
2022-02-23 05:14:32 +00:00
}
}
2021-01-20 02:06:10 +00:00
}