diff options
Diffstat (limited to 'src/Ryujinx.Tests/Audio/Renderer')
44 files changed, 1262 insertions, 0 deletions
diff --git a/src/Ryujinx.Tests/Audio/Renderer/AudioRendererConfigurationTests.cs b/src/Ryujinx.Tests/Audio/Renderer/AudioRendererConfigurationTests.cs new file mode 100644 index 00000000..6467bdf3 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/AudioRendererConfigurationTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class AudioRendererConfigurationTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x34, Unsafe.SizeOf<AudioRendererConfiguration>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/BehaviourParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/BehaviourParameterTests.cs new file mode 100644 index 00000000..cf87e15c --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/BehaviourParameterTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Common; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class BehaviourParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<BehaviourParameter>()); + Assert.AreEqual(0x10, Unsafe.SizeOf<BehaviourParameter.ErrorInfo>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/BiquadFilterParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/BiquadFilterParameterTests.cs new file mode 100644 index 00000000..0f6e3833 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/BiquadFilterParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class BiquadFilterParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0xC, Unsafe.SizeOf<BiquadFilterParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Common/UpdateDataHeaderTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Common/UpdateDataHeaderTests.cs new file mode 100644 index 00000000..f6572e55 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Common/UpdateDataHeaderTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Common; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Common +{ + class UpdateDataHeaderTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x40, Unsafe.SizeOf<UpdateDataHeader>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Common/VoiceUpdateStateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Common/VoiceUpdateStateTests.cs new file mode 100644 index 00000000..fe935cb6 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Common/VoiceUpdateStateTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Common; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Common +{ + class VoiceUpdateStateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.LessOrEqual(Unsafe.SizeOf<VoiceUpdateState>(), 0x100); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Common/WaveBufferTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Common/WaveBufferTests.cs new file mode 100644 index 00000000..f7411e71 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Common/WaveBufferTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Common; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Common +{ + class WaveBufferTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x30, Unsafe.SizeOf<WaveBuffer>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Dsp/ResamplerTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Dsp/ResamplerTests.cs new file mode 100644 index 00000000..364837ee --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Dsp/ResamplerTests.cs @@ -0,0 +1,93 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Dsp; +using Ryujinx.Audio.Renderer.Parameter; +using Ryujinx.Audio.Renderer.Server.Upsampler; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading.Tasks; + +namespace Ryujinx.Tests.Audio.Renderer.Dsp +{ + class ResamplerTests + { + [Test] + [TestCase(VoiceInParameter.SampleRateConversionQuality.Low)] + [TestCase(VoiceInParameter.SampleRateConversionQuality.Default)] + [TestCase(VoiceInParameter.SampleRateConversionQuality.High)] + public void TestResamplerConsistencyUpsampling(VoiceInParameter.SampleRateConversionQuality quality) + { + DoResamplingTest(44100, 48000, quality); + } + + [Test] + [TestCase(VoiceInParameter.SampleRateConversionQuality.Low)] + [TestCase(VoiceInParameter.SampleRateConversionQuality.Default)] + [TestCase(VoiceInParameter.SampleRateConversionQuality.High)] + public void TestResamplerConsistencyDownsampling(VoiceInParameter.SampleRateConversionQuality quality) + { + DoResamplingTest(48000, 44100, quality); + } + + /// <summary> + /// Generates a 1-second sine wave sample at input rate, resamples it to output rate, and + /// ensures that it resampled at the expected rate with no discontinuities + /// </summary> + /// <param name="inputRate">The input sample rate to test</param> + /// <param name="outputRate">The output sample rate to test</param> + /// <param name="quality">The resampler quality to use</param> + private static void DoResamplingTest(int inputRate, int outputRate, VoiceInParameter.SampleRateConversionQuality quality) + { + float inputSampleRate = (float)inputRate; + float outputSampleRate = (float)outputRate; + int inputSampleCount = inputRate; + int outputSampleCount = outputRate; + short[] inputBuffer = new short[inputSampleCount + 100]; // add some safety buffer at the end + float[] outputBuffer = new float[outputSampleCount + 100]; + for (int sample = 0; sample < inputBuffer.Length; sample++) + { + // 440 hz sine wave with amplitude = 0.5f at input sample rate + inputBuffer[sample] = (short)(32767 * MathF.Sin((440 / inputSampleRate) * (float)sample * MathF.PI * 2f) * 0.5f); + } + + float fraction = 0; + + ResamplerHelper.Resample( + outputBuffer.AsSpan(), + inputBuffer.AsSpan(), + inputSampleRate / outputSampleRate, + ref fraction, + outputSampleCount, + quality, + false); + + float[] expectedOutput = new float[outputSampleCount]; + float sumDifference = 0; + int delay = quality switch + { + VoiceInParameter.SampleRateConversionQuality.High => 3, + VoiceInParameter.SampleRateConversionQuality.Default => 1, + _ => 0 + }; + + for (int sample = 0; sample < outputSampleCount; sample++) + { + outputBuffer[sample] /= 32767; + // 440 hz sine wave with amplitude = 0.5f at output sample rate + expectedOutput[sample] = MathF.Sin((440 / outputSampleRate) * (float)(sample + delay) * MathF.PI * 2f) * 0.5f; + float thisDelta = Math.Abs(expectedOutput[sample] - outputBuffer[sample]); + + // Ensure no discontinuities + Assert.IsTrue(thisDelta < 0.1f); + sumDifference += thisDelta; + } + + sumDifference = sumDifference / (float)outputSampleCount; + // Expect the output to be 99% similar to the expected resampled sine wave + Assert.IsTrue(sumDifference < 0.01f); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Dsp/UpsamplerTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Dsp/UpsamplerTests.cs new file mode 100644 index 00000000..2018752b --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Dsp/UpsamplerTests.cs @@ -0,0 +1,64 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Dsp; +using Ryujinx.Audio.Renderer.Parameter; +using Ryujinx.Audio.Renderer.Server.Upsampler; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading.Tasks; + +namespace Ryujinx.Tests.Audio.Renderer.Dsp +{ + class UpsamplerTests + { + [Test] + public void TestUpsamplerConsistency() + { + UpsamplerBufferState bufferState = new UpsamplerBufferState(); + int inputBlockSize = 160; + int numInputSamples = 32000; + int numOutputSamples = 48000; + float inputSampleRate = numInputSamples; + float outputSampleRate = numOutputSamples; + float[] inputBuffer = new float[numInputSamples + 100]; + float[] outputBuffer = new float[numOutputSamples + 100]; + for (int sample = 0; sample < inputBuffer.Length; sample++) + { + // 440 hz sine wave with amplitude = 0.5f at input sample rate + inputBuffer[sample] = MathF.Sin((440 / inputSampleRate) * (float)sample * MathF.PI * 2f) * 0.5f; + } + + int inputIdx = 0; + int outputIdx = 0; + while (inputIdx + inputBlockSize < numInputSamples) + { + int outputBufLength = (int)Math.Round((float)(inputIdx + inputBlockSize) * outputSampleRate / inputSampleRate) - outputIdx; + UpsamplerHelper.Upsample( + outputBuffer.AsSpan(outputIdx), + inputBuffer.AsSpan(inputIdx), + outputBufLength, + inputBlockSize, + ref bufferState); + + inputIdx += inputBlockSize; + outputIdx += outputBufLength; + } + + float[] expectedOutput = new float[numOutputSamples]; + float sumDifference = 0; + for (int sample = 0; sample < numOutputSamples; sample++) + { + // 440 hz sine wave with amplitude = 0.5f at output sample rate with an offset of 15 + expectedOutput[sample] = MathF.Sin((440 / outputSampleRate) * (float)(sample - 15) * MathF.PI * 2f) * 0.5f; + sumDifference += Math.Abs(expectedOutput[sample] - outputBuffer[sample]); + } + + sumDifference = sumDifference / (float)expectedOutput.Length; + // Expect the output to be 98% similar to the expected resampled sine wave + Assert.IsTrue(sumDifference < 0.02f); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/EffectInfoParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/EffectInfoParameterTests.cs new file mode 100644 index 00000000..c4ac82f0 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/EffectInfoParameterTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class EffectInfoParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0xC0, Unsafe.SizeOf<EffectInParameterVersion1>()); + Assert.AreEqual(0xC0, Unsafe.SizeOf<EffectInParameterVersion2>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/EffectOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/EffectOutStatusTests.cs new file mode 100644 index 00000000..8cb57da3 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/EffectOutStatusTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class EffectOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<EffectOutStatusVersion1>()); + Assert.AreEqual(0x90, Unsafe.SizeOf<EffectOutStatusVersion2>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/MemoryPoolParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/MemoryPoolParameterTests.cs new file mode 100644 index 00000000..2850fd35 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/MemoryPoolParameterTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class MemoryPoolParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<MemoryPoolInParameter>()); + Assert.AreEqual(0x10, Unsafe.SizeOf<MemoryPoolOutStatus>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/BehaviourErrorInfoOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/BehaviourErrorInfoOutStatusTests.cs new file mode 100644 index 00000000..7323e720 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/BehaviourErrorInfoOutStatusTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class BehaviourErrorInfoOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0xB0, Unsafe.SizeOf<BehaviourErrorInfoOutStatus>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/AuxParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/AuxParameterTests.cs new file mode 100644 index 00000000..101bd348 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/AuxParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class AuxParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x6C, Unsafe.SizeOf<AuxiliaryBufferParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BiquadFilterEffectParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BiquadFilterEffectParameterTests.cs new file mode 100644 index 00000000..6cb7d93a --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BiquadFilterEffectParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class BiquadFilterEffectParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x18, Unsafe.SizeOf<BiquadFilterEffectParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BufferMixerParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BufferMixerParameterTests.cs new file mode 100644 index 00000000..49ff509c --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/BufferMixerParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class BufferMixerParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x94, Unsafe.SizeOf<BufferMixParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/CompressorParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/CompressorParameterTests.cs new file mode 100644 index 00000000..24b834fc --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/CompressorParameterTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class CompressorParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x38, Unsafe.SizeOf<CompressorParameter>()); + } + } +} + diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/DelayParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/DelayParameterTests.cs new file mode 100644 index 00000000..b11e3f47 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/DelayParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class DelayParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x35, Unsafe.SizeOf<DelayParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterParameterTests.cs new file mode 100644 index 00000000..8512ebd4 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterParameterTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class LimiterParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x44, Unsafe.SizeOf<LimiterParameter>()); + } + } +} + diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterStatisticsTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterStatisticsTests.cs new file mode 100644 index 00000000..43645ae4 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/LimiterStatisticsTests.cs @@ -0,0 +1,16 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class LimiterStatisticsTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x30, Unsafe.SizeOf<LimiterStatistics>()); + } + } +} + diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/Reverb3dParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/Reverb3dParameterTests.cs new file mode 100644 index 00000000..694ed55d --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/Reverb3dParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class Reverb3dParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x49, Unsafe.SizeOf<Reverb3dParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/ReverbParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/ReverbParameterTests.cs new file mode 100644 index 00000000..ef9f3457 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Effect/ReverbParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Effect; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect +{ + class ReverbParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x41, Unsafe.SizeOf<ReverbParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixInParameterDirtyOnlyUpdateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixInParameterDirtyOnlyUpdateTests.cs new file mode 100644 index 00000000..03184fdf --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixInParameterDirtyOnlyUpdateTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class MixInParameterDirtyOnlyUpdateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<MixInParameterDirtyOnlyUpdate>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixParameterTests.cs new file mode 100644 index 00000000..4fb2bb77 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/MixParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class MixParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x930, Unsafe.SizeOf<MixParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceInParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceInParameterTests.cs new file mode 100644 index 00000000..a81fa146 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceInParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Performance; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class PerformanceInParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<PerformanceInParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceOutStatusTests.cs new file mode 100644 index 00000000..e61dea2e --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/PerformanceOutStatusTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Performance; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class PerformanceOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<PerformanceOutStatus>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/RendererInfoOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/RendererInfoOutStatusTests.cs new file mode 100644 index 00000000..6b60db29 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/RendererInfoOutStatusTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class RendererInfoOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<RendererInfoOutStatus>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/CircularBufferParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/CircularBufferParameterTests.cs new file mode 100644 index 00000000..8bc37c1c --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/CircularBufferParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Sink; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Sink +{ + class CircularBufferParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x24, Unsafe.SizeOf<CircularBufferParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/DeviceParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/DeviceParameterTests.cs new file mode 100644 index 00000000..27ae2b47 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/Sink/DeviceParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter.Sink; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter.Sink +{ + class DeviceParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x11C, Unsafe.SizeOf<DeviceParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkInParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkInParameterTests.cs new file mode 100644 index 00000000..21a17889 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkInParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class SinkInParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x140, Unsafe.SizeOf<SinkInParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkOutStatusTests.cs new file mode 100644 index 00000000..828248af --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SinkOutStatusTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class SinkOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<SinkOutStatus>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Parameter/SplitterInParamHeaderTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SplitterInParamHeaderTests.cs new file mode 100644 index 00000000..fc966e4c --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Parameter/SplitterInParamHeaderTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Parameter +{ + class SplitterInParamHeaderTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<SplitterInParameterHeader>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/AddressInfoTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/AddressInfoTests.cs new file mode 100644 index 00000000..7c6b6526 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/AddressInfoTests.cs @@ -0,0 +1,35 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.MemoryPool; +using System; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class AddressInfoTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<AddressInfo>()); + } + + [Test] + public void TestGetReference() + { + MemoryPoolState[] memoryPoolState = new MemoryPoolState[1]; + memoryPoolState[0] = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + memoryPoolState[0].SetCpuAddress(0x1000000, 0x10000); + memoryPoolState[0].DspAddress = 0x4000000; + + AddressInfo addressInfo = AddressInfo.Create(0x1000000, 0x1000); + + addressInfo.ForceMappedDspAddress = 0x2000000; + + Assert.AreEqual(0x2000000, addressInfo.GetReference(true)); + + addressInfo.SetupMemoryPool(memoryPoolState.AsSpan()); + + Assert.AreEqual(0x4000000, addressInfo.GetReference(true)); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/BehaviourContextTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/BehaviourContextTests.cs new file mode 100644 index 00000000..df946a12 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/BehaviourContextTests.cs @@ -0,0 +1,296 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + public class BehaviourContextTests + { + [Test] + public void TestCheckFeature() + { + int latestRevision = BehaviourContext.BaseRevisionMagic + BehaviourContext.LastRevision; + int previousRevision = BehaviourContext.BaseRevisionMagic + (BehaviourContext.LastRevision - 1); + int invalidRevision = BehaviourContext.BaseRevisionMagic + (BehaviourContext.LastRevision + 1); + + Assert.IsTrue(BehaviourContext.CheckFeatureSupported(latestRevision, latestRevision)); + Assert.IsFalse(BehaviourContext.CheckFeatureSupported(previousRevision, latestRevision)); + Assert.IsTrue(BehaviourContext.CheckFeatureSupported(latestRevision, previousRevision)); + // In case we get an invalid revision, this is supposed to auto default to REV1 internally.. idk what the hell Nintendo was thinking here.. + Assert.IsTrue(BehaviourContext.CheckFeatureSupported(invalidRevision, latestRevision)); + } + + [Test] + public void TestsMemoryPoolForceMappingEnabled() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision1); + + Assert.IsFalse(behaviourContext.IsMemoryPoolForceMappingEnabled()); + + behaviourContext.UpdateFlags(0x1); + + Assert.IsTrue(behaviourContext.IsMemoryPoolForceMappingEnabled()); + } + + [Test] + public void TestRevision1() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision1); + + Assert.IsFalse(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsFalse(behaviourContext.IsSplitterSupported()); + Assert.IsFalse(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsFalse(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsFalse(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsFalse(behaviourContext.IsSplitterBugFixed()); + Assert.IsFalse(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsFalse(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.70f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(1, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(1, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision2() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision2); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsFalse(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsFalse(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsFalse(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsFalse(behaviourContext.IsSplitterBugFixed()); + Assert.IsFalse(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsFalse(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.70f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(1, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(1, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision3() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision3); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsFalse(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsFalse(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsFalse(behaviourContext.IsSplitterBugFixed()); + Assert.IsFalse(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsFalse(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.70f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(1, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(1, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision4() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision4); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsFalse(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsFalse(behaviourContext.IsSplitterBugFixed()); + Assert.IsFalse(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsFalse(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.75f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(1, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(1, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision5() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision5); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(2, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision6() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision6); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsFalse(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(2, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision7() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision7); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsTrue(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsFalse(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(2, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision8() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision8); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsTrue(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsTrue(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsFalse(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(3, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision9() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision9); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsTrue(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsTrue(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsTrue(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsFalse(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(3, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + + [Test] + public void TestRevision10() + { + BehaviourContext behaviourContext = new BehaviourContext(); + + behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision10); + + Assert.IsTrue(behaviourContext.IsAdpcmLoopContextBugFixed()); + Assert.IsTrue(behaviourContext.IsSplitterSupported()); + Assert.IsTrue(behaviourContext.IsLongSizePreDelaySupported()); + Assert.IsTrue(behaviourContext.IsAudioUsbDeviceOutputSupported()); + Assert.IsTrue(behaviourContext.IsFlushVoiceWaveBuffersSupported()); + Assert.IsTrue(behaviourContext.IsSplitterBugFixed()); + Assert.IsTrue(behaviourContext.IsElapsedFrameCountSupported()); + Assert.IsTrue(behaviourContext.IsDecodingBehaviourFlagSupported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterEffectStateClearBugFixed()); + Assert.IsTrue(behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported()); + Assert.IsTrue(behaviourContext.IsWaveBufferVersion2Supported()); + Assert.IsTrue(behaviourContext.IsEffectInfoVersion2Supported()); + Assert.IsTrue(behaviourContext.IsBiquadFilterGroupedOptimizationSupported()); + + Assert.AreEqual(0.80f, behaviourContext.GetAudioRendererProcessingTimeLimit()); + Assert.AreEqual(4, behaviourContext.GetCommandProcessingTimeEstimatorVersion()); + Assert.AreEqual(2, behaviourContext.GetPerformanceMetricsDataFormat()); + } + } +}
\ No newline at end of file diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/MemoryPoolStateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/MemoryPoolStateTests.cs new file mode 100644 index 00000000..94dc6906 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/MemoryPoolStateTests.cs @@ -0,0 +1,62 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.MemoryPool; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class MemoryPoolStateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(Unsafe.SizeOf<MemoryPoolState>(), 0x20); + } + + [Test] + public void TestContains() + { + MemoryPoolState memoryPool = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + memoryPool.SetCpuAddress(0x1000000, 0x1000); + + memoryPool.DspAddress = 0x2000000; + + Assert.IsTrue(memoryPool.Contains(0x1000000, 0x10)); + Assert.IsTrue(memoryPool.Contains(0x1000FE0, 0x10)); + Assert.IsTrue(memoryPool.Contains(0x1000FFF, 0x1)); + Assert.IsFalse(memoryPool.Contains(0x1000FFF, 0x2)); + Assert.IsFalse(memoryPool.Contains(0x1001000, 0x10)); + Assert.IsFalse(memoryPool.Contains(0x2000000, 0x10)); + } + + [Test] + public void TestTranslate() + { + MemoryPoolState memoryPool = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + memoryPool.SetCpuAddress(0x1000000, 0x1000); + + memoryPool.DspAddress = 0x2000000; + + Assert.AreEqual(0x2000FE0, memoryPool.Translate(0x1000FE0, 0x10)); + Assert.AreEqual(0x2000FFF, memoryPool.Translate(0x1000FFF, 0x1)); + Assert.AreEqual(0x0, memoryPool.Translate(0x1000FFF, 0x2)); + Assert.AreEqual(0x0, memoryPool.Translate(0x1001000, 0x10)); + Assert.AreEqual(0x0, memoryPool.Translate(0x2000000, 0x10)); + } + + [Test] + public void TestIsMapped() + { + MemoryPoolState memoryPool = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + memoryPool.SetCpuAddress(0x1000000, 0x1000); + + Assert.IsFalse(memoryPool.IsMapped()); + + memoryPool.DspAddress = 0x2000000; + + Assert.IsTrue(memoryPool.IsMapped()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/MixStateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/MixStateTests.cs new file mode 100644 index 00000000..d1ddf64d --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/MixStateTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Mix; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class MixStateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x940, Unsafe.SizeOf<MixState>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/PoolMapperTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/PoolMapperTests.cs new file mode 100644 index 00000000..d2c2e6cb --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/PoolMapperTests.cs @@ -0,0 +1,135 @@ +using NUnit.Framework; +using Ryujinx.Audio; +using Ryujinx.Audio.Renderer.Server.MemoryPool; +using System; +using static Ryujinx.Audio.Renderer.Common.BehaviourParameter; +using CpuAddress = System.UInt64; +using DspAddress = System.UInt64; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class PoolMapperTests + { + private const uint DummyProcessHandle = 0xCAFEBABE; + + [Test] + public void TestInitializeSystemPool() + { + PoolMapper poolMapper = new PoolMapper(DummyProcessHandle, true); + MemoryPoolState memoryPoolDsp = MemoryPoolState.Create(MemoryPoolState.LocationType.Dsp); + MemoryPoolState memoryPoolCpu = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + const CpuAddress CpuAddress = 0x20000; + const DspAddress DspAddress = CpuAddress; // TODO: DSP LLE + const ulong CpuSize = 0x1000; + + Assert.IsFalse(poolMapper.InitializeSystemPool(ref memoryPoolCpu, CpuAddress, CpuSize)); + Assert.IsTrue(poolMapper.InitializeSystemPool(ref memoryPoolDsp, CpuAddress, CpuSize)); + + Assert.AreEqual(CpuAddress, memoryPoolDsp.CpuAddress); + Assert.AreEqual(CpuSize, memoryPoolDsp.Size); + Assert.AreEqual(DspAddress, memoryPoolDsp.DspAddress); + } + + [Test] + public void TestGetProcessHandle() + { + PoolMapper poolMapper = new PoolMapper(DummyProcessHandle, true); + MemoryPoolState memoryPoolDsp = MemoryPoolState.Create(MemoryPoolState.LocationType.Dsp); + MemoryPoolState memoryPoolCpu = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + Assert.AreEqual(0xFFFF8001, poolMapper.GetProcessHandle(ref memoryPoolCpu)); + Assert.AreEqual(DummyProcessHandle, poolMapper.GetProcessHandle(ref memoryPoolDsp)); + } + + [Test] + public void TestMappings() + { + PoolMapper poolMapper = new PoolMapper(DummyProcessHandle, true); + MemoryPoolState memoryPoolDsp = MemoryPoolState.Create(MemoryPoolState.LocationType.Dsp); + MemoryPoolState memoryPoolCpu = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + + const CpuAddress CpuAddress = 0x20000; + const DspAddress DspAddress = CpuAddress; // TODO: DSP LLE + const ulong CpuSize = 0x1000; + + memoryPoolDsp.SetCpuAddress(CpuAddress, CpuSize); + memoryPoolCpu.SetCpuAddress(CpuAddress, CpuSize); + + Assert.AreEqual(DspAddress, poolMapper.Map(ref memoryPoolCpu)); + Assert.AreEqual(DspAddress, poolMapper.Map(ref memoryPoolDsp)); + Assert.AreEqual(DspAddress, memoryPoolDsp.DspAddress); + Assert.IsTrue(poolMapper.Unmap(ref memoryPoolCpu)); + + memoryPoolDsp.IsUsed = true; + Assert.IsFalse(poolMapper.Unmap(ref memoryPoolDsp)); + memoryPoolDsp.IsUsed = false; + Assert.IsTrue(poolMapper.Unmap(ref memoryPoolDsp)); + } + + [Test] + public void TestTryAttachBuffer() + { + const CpuAddress CpuAddress = 0x20000; + const DspAddress DspAddress = CpuAddress; // TODO: DSP LLE + const ulong CpuSize = 0x1000; + + const int MemoryPoolStateArraySize = 0x10; + const CpuAddress CpuAddressRegionEnding = CpuAddress * MemoryPoolStateArraySize; + + MemoryPoolState[] memoryPoolStateArray = new MemoryPoolState[MemoryPoolStateArraySize]; + + for (int i = 0; i < memoryPoolStateArray.Length; i++) + { + memoryPoolStateArray[i] = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu); + memoryPoolStateArray[i].SetCpuAddress(CpuAddress + (ulong)i * CpuSize, CpuSize); + } + + ErrorInfo errorInfo; + + AddressInfo addressInfo = AddressInfo.Create(); + + PoolMapper poolMapper = new PoolMapper(DummyProcessHandle, true); + + Assert.IsTrue(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, 0, 0)); + + Assert.AreEqual(ResultCode.InvalidAddressInfo, errorInfo.ErrorCode); + Assert.AreEqual(0, errorInfo.ExtraErrorInfo); + Assert.AreEqual(0, addressInfo.ForceMappedDspAddress); + + Assert.IsTrue(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, CpuAddress, CpuSize)); + + Assert.AreEqual(ResultCode.InvalidAddressInfo, errorInfo.ErrorCode); + Assert.AreEqual(CpuAddress, errorInfo.ExtraErrorInfo); + Assert.AreEqual(DspAddress, addressInfo.ForceMappedDspAddress); + + poolMapper = new PoolMapper(DummyProcessHandle, false); + + Assert.IsFalse(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, 0, 0)); + + addressInfo.ForceMappedDspAddress = 0; + + Assert.IsFalse(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, CpuAddress, CpuSize)); + + Assert.AreEqual(ResultCode.InvalidAddressInfo, errorInfo.ErrorCode); + Assert.AreEqual(CpuAddress, errorInfo.ExtraErrorInfo); + Assert.AreEqual(0, addressInfo.ForceMappedDspAddress); + + poolMapper = new PoolMapper(DummyProcessHandle, memoryPoolStateArray.AsMemory(), false); + + Assert.IsFalse(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, CpuAddressRegionEnding, CpuSize)); + + Assert.AreEqual(ResultCode.InvalidAddressInfo, errorInfo.ErrorCode); + Assert.AreEqual(CpuAddressRegionEnding, errorInfo.ExtraErrorInfo); + Assert.AreEqual(0, addressInfo.ForceMappedDspAddress); + Assert.IsFalse(addressInfo.HasMemoryPoolState); + + Assert.IsTrue(poolMapper.TryAttachBuffer(out errorInfo, ref addressInfo, CpuAddress, CpuSize)); + + Assert.AreEqual(ResultCode.Success, errorInfo.ErrorCode); + Assert.AreEqual(0, errorInfo.ExtraErrorInfo); + Assert.AreEqual(0, addressInfo.ForceMappedDspAddress); + Assert.IsTrue(addressInfo.HasMemoryPoolState); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterDestinationTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterDestinationTests.cs new file mode 100644 index 00000000..51362954 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterDestinationTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Splitter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class SplitterDestinationTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0xE0, Unsafe.SizeOf<SplitterDestination>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterStateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterStateTests.cs new file mode 100644 index 00000000..2486f8c0 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/SplitterStateTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Splitter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class SplitterStateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x20, Unsafe.SizeOf<SplitterState>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceChannelResourceTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceChannelResourceTests.cs new file mode 100644 index 00000000..0b867286 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceChannelResourceTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Voice; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class VoiceChannelResourceTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0xD0, Unsafe.SizeOf<VoiceChannelResource>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceStateTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceStateTests.cs new file mode 100644 index 00000000..ddd05bc4 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/VoiceStateTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Voice; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class VoiceStateTests + { + [Test] + public void EnsureTypeSize() + { + Assert.LessOrEqual(Unsafe.SizeOf<VoiceState>(), 0x220); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/Server/WaveBufferTests.cs b/src/Ryujinx.Tests/Audio/Renderer/Server/WaveBufferTests.cs new file mode 100644 index 00000000..9f3889c0 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/Server/WaveBufferTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Server.Voice; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer.Server +{ + class WaveBufferTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x58, Unsafe.SizeOf<WaveBuffer>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/VoiceChannelResourceInParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/VoiceChannelResourceInParameterTests.cs new file mode 100644 index 00000000..b04f505e --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/VoiceChannelResourceInParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class VoiceChannelResourceInParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x70, Unsafe.SizeOf<VoiceChannelResourceInParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/VoiceInParameterTests.cs b/src/Ryujinx.Tests/Audio/Renderer/VoiceInParameterTests.cs new file mode 100644 index 00000000..9770189c --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/VoiceInParameterTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class VoiceInParameterTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x170, Unsafe.SizeOf<VoiceInParameter>()); + } + } +} diff --git a/src/Ryujinx.Tests/Audio/Renderer/VoiceOutStatusTests.cs b/src/Ryujinx.Tests/Audio/Renderer/VoiceOutStatusTests.cs new file mode 100644 index 00000000..abef0646 --- /dev/null +++ b/src/Ryujinx.Tests/Audio/Renderer/VoiceOutStatusTests.cs @@ -0,0 +1,15 @@ +using NUnit.Framework; +using Ryujinx.Audio.Renderer.Parameter; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Tests.Audio.Renderer +{ + class VoiceOutStatusTests + { + [Test] + public void EnsureTypeSize() + { + Assert.AreEqual(0x10, Unsafe.SizeOf<VoiceOutStatus>()); + } + } +} |