mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Audio: Remove voice mixing optimizations.

Browse source 
Leaves Saturation optimizations in place.
This commit is contained in:
jduncanator 2018-11-15 13:19:02 +11:00
commit c20c1e7481
1 changed files with 21 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

71
Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
View file

@ -309,8 +309,6 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
{
int[] MixBuffer = new int[MixBufferSamplesCount * AudioConsts.HostChannelsCount];
fixed (int* mixptr = MixBuffer)
{
foreach (VoiceContext Voice in Voices)
{
if (!Voice.Playing)
@ -333,74 +331,9 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
PendingSamples -= ReturnedSamples;
int Offset = 0;
if(Avx2.IsSupported && Avx.IsSupported)
for (int Offset = 0; Offset < Samples.Length; Offset++)
{
fixed (int* samptr = Samples)
{
// Load our scale factor as a scalar
Vector256<float> volume = Avx.SetAllVector256(Volume);
for (; Offset + 32 <= Samples.Length; Offset += 32, OutOffset += 32)
{
// Convert our samples from ints to floats
Vector256<float> samples1 = Avx.ConvertToVector256Single(Avx.LoadVector256(samptr + Offset + 0));
Vector256<float> samples2 = Avx.ConvertToVector256Single(Avx.LoadVector256(samptr + Offset + 8));
Vector256<float> samples3 = Avx.ConvertToVector256Single(Avx.LoadVector256(samptr + Offset + 16));
Vector256<float> samples4 = Avx.ConvertToVector256Single(Avx.LoadVector256(samptr + Offset + 24));
Vector256<int> mix1 = Avx.LoadVector256(mixptr + OutOffset + 0);
Vector256<int> mix2 = Avx.LoadVector256(mixptr + OutOffset + 8);
Vector256<int> mix3 = Avx.LoadVector256(mixptr + OutOffset + 16);
Vector256<int> mix4 = Avx.LoadVector256(mixptr + OutOffset + 24);
// Scale by the volume and store back as ints
// TODO: Implement this as an FMA operation once Intrinsics
// gets support for FMA in their AVX2 implementation.
Avx.Store(mixptr + OutOffset + 0, Avx2.Add(mix1, Avx.ConvertToVector256Int32(Avx.Multiply(samples1, volume))));
Avx.Store(mixptr + OutOffset + 8, Avx2.Add(mix2, Avx.ConvertToVector256Int32(Avx.Multiply(samples2, volume))));
Avx.Store(mixptr + OutOffset + 16, Avx2.Add(mix3, Avx.ConvertToVector256Int32(Avx.Multiply(samples3, volume))));
Avx.Store(mixptr + OutOffset + 24, Avx2.Add(mix4, Avx.ConvertToVector256Int32(Avx.Multiply(samples4, volume))));
}
}
}
else if (Sse2.IsSupported && Sse.IsSupported)
{
fixed (int* samptr = Samples)
{
// Load our scale factor as a scalar
Vector128<float> volume = Sse.SetAllVector128(Volume);
for (; Offset + 16 <= Samples.Length; Offset += 16, OutOffset += 16)
{
// Convert our samples from ints to floats
Vector128<float> samples1 = Sse2.ConvertToVector128Single(Sse2.LoadVector128(samptr + Offset + 0));
Vector128<float> samples2 = Sse2.ConvertToVector128Single(Sse2.LoadVector128(samptr + Offset + 4));
Vector128<float> samples3 = Sse2.ConvertToVector128Single(Sse2.LoadVector128(samptr + Offset + 8));
Vector128<float> samples4 = Sse2.ConvertToVector128Single(Sse2.LoadVector128(samptr + Offset + 12));
Vector128<int> mix1 = Sse2.LoadVector128(mixptr + OutOffset + 0);
Vector128<int> mix2 = Sse2.LoadVector128(mixptr + OutOffset + 4);
Vector128<int> mix3 = Sse2.LoadVector128(mixptr + OutOffset + 8);
Vector128<int> mix4 = Sse2.LoadVector128(mixptr + OutOffset + 12);
// Scale by the volume and store back as ints
Sse2.Store(mixptr + OutOffset + 0, Sse2.Add(mix1, Sse2.ConvertToVector128Int32(Sse.Multiply(samples1, volume))));
Sse2.Store(mixptr + OutOffset + 4, Sse2.Add(mix2, Sse2.ConvertToVector128Int32(Sse.Multiply(samples2, volume))));
Sse2.Store(mixptr + OutOffset + 8, Sse2.Add(mix3, Sse2.ConvertToVector128Int32(Sse.Multiply(samples3, volume))));
Sse2.Store(mixptr + OutOffset + 12, Sse2.Add(mix4, Sse2.ConvertToVector128Int32(Sse.Multiply(samples4, volume))));
}
}
}
// Process left overs
for (; Offset < Samples.Length; Offset++)
{
int Sample = (int)(Samples[Offset] * Voice.Volume);
MixBuffer[OutOffset++] += Sample;
}
MixBuffer[OutOffset++] += (int)(Samples[Offset] * Voice.Volume);
}
}
}