private const int SamplesPerFrame = 14;

private const int NibblesPerFrame = SamplesPerFrame + 2;

private const int BytesPerFrame = 8;

private const int BitsPerFrame = BytesPerFrame * 8;

[MethodImpl(MethodImplOptions.AggressiveInlining)]

public static uint GetAdpcmDataSize(int sampleCount)

private static short Saturate(int value)

{

if (value > short.MaxValue)

value = short.MaxValue;

if (value < short.MinValue)

value = short.MinValue;

return (short)value;

}

ReadOnlySpan<byte> targetInput;

while (remaining > 0)

{

return decodedCount;

}

}

Start,

Stop,

RenderStart,

}

private class RendererSession

private long _lastTime;

private long _playbackEnds;

private ManualResetEvent _pauseEvent;

_event = new ManualResetEvent(false);

}

private static uint GetHardwareChannelCount(IHardwareDeviceDriver deviceDriver)

{

// Get the real device driver (In case the compat layer is on top of it).

{

return 6;

}

}

public void Start(IHardwareDeviceDriver deviceDriver, float volume)

{

{

CommandList = commands,

RenderingLimit = renderingLimit,

};

}

{

_workerThread = new Thread(Work)

{

};

_workerThread.Start();

public void Dispose()

{

Dispose(true);

}

}

}

}

}

}

}

using Ryujinx.Audio.Common;

using Ryujinx.Audio.Renderer.Common;

using System;

using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;

namespace Ryujinx.Audio.Renderer.Dsp.Command

{

public DecodingBehaviour DecodingBehaviour { get; }

{

Enabled = true;

NodeId = nodeId;

{

Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);

{

SourceSampleRate = SampleRate,

SampleFormat = SampleFormat.Adpcm,

DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);

}

}

if (readResult != context.SampleCount)

{

}

}

else

}

}

}

BiquadFilterHelper.ProcessBiquadFilter(ref _parameter, ref state, outputBuffer, inputBuffer, context.SampleCount);

}

}

}

}

}

context.ClearBuffers();

}

}

return (IntPtr)((float*)_buffersMemoryHandle.Pointer + index * _sampleCount);

}

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

public void Dispose()

{

_buffersMemoryHandle.Dispose();

}

}

LimiterVersion2,

GroupedBiquadFilter,

CaptureBuffer,

}

using Ryujinx.Audio.Renderer.Dsp.Effect;

using Ryujinx.Audio.Renderer.Dsp.State;

using Ryujinx.Audio.Renderer.Parameter.Effect;

using System;

using System.Diagnostics;

if (IsEffectEnabled)

{

{

state = new CompressorState(ref _parameter);

}

{

state.UpdateParameter(ref _parameter);

}

context.CopyBuffer(OutputBufferIndex, InputBufferIndex);

}

}

using Ryujinx.Audio.Common;

using Ryujinx.Audio.Renderer.Common;

using System;

using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;

namespace Ryujinx.Audio.Renderer.Dsp.Command

{

public SampleRateConversionQuality SrcQuality { get; }

{

Enabled = true;

NodeId = nodeId;

private static CommandType GetCommandTypeBySampleFormat(SampleFormat sampleFormat)

{

{

}

public void Process(CommandList context)

{

Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);

{

SourceSampleRate = SampleRate,

SampleFormat = SampleFormat,

ExtraParameterSize = ExtraParameterSize,

ChannelIndex = (int)ChannelIndex,

ChannelCount = (int)ChannelCount,

};

DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);

}

}

float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);

float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

delayFeedbackCrossGain, delayFeedbackBaseGain);

for (int i = 0; i < sampleCount; i++)

{

{

X = *((float*)inputBuffers[0] + i) * 64,

Y = *((float*)inputBuffers[1] + i) * 64,

};

{

X = state.DelayLines[0].Read(),

Y = state.DelayLines[1].Read(),

float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);

float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain,

delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,

0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);

for (int i = 0; i < sampleCount; i++)

{

{

X = *((float*)inputBuffers[0] + i) * 64,

Y = *((float*)inputBuffers[1] + i) * 64,

Z = *((float*)inputBuffers[2] + i) * 64,

};

{

X = state.DelayLines[0].Read(),

Y = state.DelayLines[1].Read(),

Z = state.DelayLines[2].Read(),

};

Vector4 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;

float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);

float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain,

delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, 0.0f, 0.0f,

0.0f, 0.0f, 0.0f, feedbackGain, 0.0f, 0.0f,

for (int i = 0; i < sampleCount; i++)

{

{

X = *((float*)inputBuffers[0] + i) * 64,

Y = *((float*)inputBuffers[1] + i) * 64,

Z = *((float*)inputBuffers[2] + i) * 64,

W = *((float*)inputBuffers[3] + i) * 64,

V = *((float*)inputBuffers[4] + i) * 64,

};

{

X = state.DelayLines[0].Read(),

Y = state.DelayLines[1].Read(),

Z = state.DelayLines[2].Read(),

W = state.DelayLines[3].Read(),

V = state.DelayLines[4].Read(),

};

Vector6 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;

return -depopValue;

}

}

}

public void Process(CommandList context)

}

}

}

}

}

}

context.ClearBuffer(OutputBufferIndices[5]);

}

}

public uint EstimatedProcessingTime { get; set; }

public GroupedBiquadFilterCommand(int baseIndex, ReadOnlySpan<BiquadFilterParameter> filters, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)

{

}

}

}

return false;

}

}

using Ryujinx.Audio.Renderer.Dsp.State;

using Ryujinx.Audio.Renderer.Parameter.Effect;

using System;

using System.Diagnostics;

if (IsEffectEnabled)

{

{

state = new LimiterState(ref _parameter, WorkBuffer);

}

{

}

}

}

}

}

using Ryujinx.Audio.Renderer.Dsp.State;

using Ryujinx.Audio.Renderer.Parameter;

using Ryujinx.Audio.Renderer.Parameter.Effect;

using System;

using System.Diagnostics;

using System.Runtime.InteropServices;

if (IsEffectEnabled)

{

{

state = new LimiterState(ref _parameter, WorkBuffer);

}

{

}

}

}

}

}

ProcessMix(outputBuffer, inputBuffer);

}

}

State.Span[0].LastSamples[LastSampleIndex] = ProcessMixRamp(outputBuffer, inputBuffer, (int)context.SampleCount);

}

}

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

{

float ramp = (volume1 - volume0) / sampleCount;

float volume = volume0;

}

}

}

using Ryujinx.Audio.Common;

using Ryujinx.Audio.Renderer.Common;

using System;

using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;

namespace Ryujinx.Audio.Renderer.Dsp.Command

{

public Memory<VoiceUpdateState> State { get; }

public DecodingBehaviour DecodingBehaviour { get; }

{

Enabled = true;

NodeId = nodeId;

{

Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);

{

SourceSampleRate = SampleRate,

SampleFormat = SampleFormat.PcmFloat,

DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);

}

}

using Ryujinx.Audio.Common;

using Ryujinx.Audio.Renderer.Common;

using System;

using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;

namespace Ryujinx.Audio.Renderer.Dsp.Command

{

public Memory<VoiceUpdateState> State { get; }

public DecodingBehaviour DecodingBehaviour { get; }

{

Enabled = true;

NodeId = nodeId;

{

Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);

{

SourceSampleRate = SampleRate,

SampleFormat = SampleFormat.PcmInt16,

DataSourceHelper.ProcessWaveBuffers(context.MemoryManager, outputBuffer, ref info, WaveBuffers, ref State.Span[0], context.SampleRate, (int)context.SampleCount);

}

}

{

Invalid,

Start,

}

public bool Enabled { get; set; }

}

}

}

{

public class Reverb3dCommand : ICommand

{

public bool Enabled { get; set; }

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void ProcessReverb3dMono(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void ProcessReverb3dStereo(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void ProcessReverb3dQuadraphonic(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void ProcessReverb3dSurround(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

}

private unsafe void ProcessReverb3dGeneric(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable)

for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)

{

float tapOut = state.PreDelayLine.TapUnsafe(state.ReflectionDelayTime, DelayLineSampleIndexOffset);

using Ryujinx.Audio.Renderer.Dsp.State;

using Ryujinx.Audio.Renderer.Parameter.Effect;

using System;

using System.Diagnostics;

using System.Runtime.CompilerServices;

{

public class ReverbCommand : ICommand

{

public bool Enabled { get; set; }

outputBuffers,

inputBuffers,

sampleCount,

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

outputBuffers,

inputBuffers,

sampleCount,

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

outputBuffers,

inputBuffers,

sampleCount,

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

outputBuffers,

inputBuffers,

sampleCount,

}

private unsafe void ProcessReverbGeneric(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable, ReadOnlySpan<int> outputIndicesTable)

for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)

{

for (int i = 0; i < targetEarlyDelayLineIndicesTable.Length; i++)

{

if (IsEffectEnabled)

{

{

state = new ReverbState(ref _parameter, WorkBuffer, IsLongSizePreDelaySupported);

}

{

state.UpdateParameter(ref _parameter);

}

ProcessReverb(context, ref state);

}

}

}

}

}

ProcessVolume(outputBuffer, inputBuffer);

}

}

ProcessVolumeRamp(outputBuffer, inputBuffer, (int)context.SampleCount);

}

}

if (!info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))

{

tempBufferIndex += pitchMaxLength;

}

voiceState.LoopContext = memoryManager.Read<AdpcmLoopContext>(waveBuffer.Context);

}

int decodedSampleCount = -1;

decodedSampleCount = PcmHelper.Decode(tempSpan, waveBufferPcmFloat, targetSampleStartOffset, targetSampleEndOffset, info.ChannelIndex, info.ChannelCount);

break;

default:

break;

}

}

}

if (info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))

{

}

else

{

ToFloat(outputBuffer, outputSpanInt, sampleCountToProcess);

return _delayLine.Tap(sampleIndex);

}

}

{

public class DelayLine : IDelayLine

{

private uint _currentSampleIndex;

private uint _lastSampleIndex;

return TapUnsafe(sampleIndex, -1);

}

}

{

public class DelayLine3d : IDelayLine

{

private uint _currentSampleIndex;

private uint _lastSampleIndex;

return TapUnsafe(sampleIndex, -1);

}

}

{

public struct ExponentialMovingAverage

{

_mean = mean;

}

{

return _mean;

}

return (uint)MathF.Round(sampleRate * delayTime);

}

}

return ToInt(value + half, qBits);

}

}

using System;

using System.Runtime.CompilerServices;

namespace Ryujinx.Audio.Renderer.Dsp

{

return 1.0f;

}

{

return 0.0f;

}

return MathF.Sin(DegreesToRadians(value));

}

}

using System;

using System.Runtime.CompilerServices;

namespace Ryujinx.Audio.Renderer.Dsp

{

for (int i = 0; i < input.Length; i++)

{

}

}

return (short)value;

}

}

using System;

using System.Linq;

using System.Runtime.CompilerServices;

using System.Runtime.Intrinsics;

using System.Runtime.Intrinsics.X86;

public static class ResamplerHelper

{

#region "Default Quality Lookup Tables"

6600, 19426, 6722, 3, 6479, 19424, 6845, 9, 6359, 19419, 6968, 15, 6239, 19412, 7093, 22,

6121, 19403, 7219, 28, 6004, 19391, 7345, 34, 5888, 19377, 7472, 41, 5773, 19361, 7600, 48,

5659, 19342, 7728, 55, 5546, 19321, 7857, 62, 5434, 19298, 7987, 69, 5323, 19273, 8118, 77,

109, 8646, 19148, 4890, 101, 8513, 19183, 4997, 92, 8381, 19215, 5104, 84, 8249, 19245, 5213,

77, 8118, 19273, 5323, 69, 7987, 19298, 5434, 62, 7857, 19321, 5546, 55, 7728, 19342, 5659,

48, 7600, 19361, 5773, 41, 7472, 19377, 5888, 34, 7345, 19391, 6004, 28, 7219, 19403, 6121,

};

-68, 32639, 69, -5, -200, 32630, 212, -15, -328, 32613, 359, -26, -450, 32586, 512, -36,

-568, 32551, 669, -47, -680, 32507, 832, -58, -788, 32454, 1000, -69, -891, 32393, 1174, -80,

-990, 32323, 1352, -92, -1084, 32244, 1536, -103, -1173, 32157, 1724, -115, -1258, 32061, 1919, -128,

-180, 2747, 31593, -1554, -167, 2532, 31723, -1486, -153, 2322, 31844, -1414, -140, 2118, 31956, -1338,

-128, 1919, 32061, -1258, -115, 1724, 32157, -1173, -103, 1536, 32244, -1084, -92, 1352, 32323, -990,

-80, 1174, 32393, -891, -69, 1000, 32454, -788, -58, 832, 32507, -680, -47, 669, 32551, -568,

};

3195, 26287, 3329, -32, 3064, 26281, 3467, -34, 2936, 26270, 3608, -38, 2811, 26253, 3751, -42,

2688, 26230, 3897, -46, 2568, 26202, 4046, -50, 2451, 26169, 4199, -54, 2338, 26130, 4354, -58,

2227, 26085, 4512, -63, 2120, 26035, 4673, -67, 2015, 25980, 4837, -72, 1912, 25919, 5004, -76,

-98, 5701, 25621, 1531, -92, 5522, 25704, 1622, -87, 5347, 25780, 1716, -81, 5174, 25852, 1813,

-76, 5004, 25919, 1912, -72, 4837, 25980, 2015, -67, 4673, 26035, 2120, -63, 4512, 26085, 2227,

-58, 4354, 26130, 2338, -54, 4199, 26169, 2451, -50, 4046, 26202, 2568, -46, 3897, 26230, 2688,

};

#endregion

#region "High Quality Lookup Tables"

-582, -23, 8740, 16386, 8833, 8, -590, 0, -573, -54, 8647, 16385, 8925, 40, -598, -1,

-565, -84, 8555, 16383, 9018, 72, -606, -1, -557, -113, 8462, 16379, 9110, 105, -614, -2,

-549, -142, 8370, 16375, 9203, 139, -622, -2, -541, -170, 8277, 16369, 9295, 173, -630, -3,

-1, -598, 40, 8925, 16385, 8647, -54, -573, 0, -590, 8, 8833, 16386, 8740, -23, -582,

};

-12, 47, -134, 32767, 81, -16, 2, 0, -26, 108, -345, 32760, 301, -79, 17, -1,

-40, 168, -552, 32745, 526, -144, 32, -2, -53, 226, -753, 32723, 755, -210, 47, -3,

-66, 284, -950, 32694, 989, -277, 63, -5, -78, 340, -1143, 32658, 1226, -346, 79, -6,

-1, 17, -79, 301, 32760, -345, 108, -26, 0, 2, -16, 81, 32767, -134, 47, -12,

};

418, -2538, 6118, 24615, 6298, -2563, 417, 0, 420, -2512, 5939, 24611, 6479, -2588, 415, 1,

421, -2485, 5761, 24605, 6662, -2612, 412, 2, 422, -2458, 5585, 24595, 6846, -2635, 409, 3,

423, -2430, 5410, 24582, 7030, -2658, 406, 4, 423, -2402, 5236, 24565, 7216, -2680, 403, 5,

};

#endregion

static ResamplerHelper()

{

{

return _normalCurveLut1F;

}

{

return _normalCurveLut0F;

}

{

return _highCurveLut1F;

}

{

return _highCurveLut0F;

}

}

}

}

public short History0;

public short History1;

}

public AuxiliaryBufferInfo CpuBufferInfo;

public AuxiliaryBufferInfo DspBufferInfo;

}

public float State2;

public float State3;

}

}

}

}

DetectorAverage.AsSpan().Fill(new ExponentialMovingAverage(0.0f));

CompressionGainAverage.AsSpan().Fill(new ExponentialMovingAverage(1.0f));

UpdateParameter(ref parameter);

}

}

{

public class Reverb3dState

{

public readonly float[] EarlyGain = new float[20] { 0.67096f, 0.61027f, 1.0f, 0.35680f, 0.68361f, 0.65978f, 0.51939f, 0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f, 0.72867f, 0.69794f, 0.5464f, 0.24563f, 0.45214f, 0.44042f };

public IDelayLine[] FdnDelayLines { get; }

for (int i = 0; i < 4; i++)

{

}

PreDelayLine = new DelayLine3d(sampleRate, 400);

EarlyDelayTime = new uint[20];

DryGain = parameter.DryGain;

PreviousPreDelayValue = 0;

EarlyReflectionsGain = FloatingPointHelper.Pow10(Math.Min(parameter.RoomGain + parameter.ReflectionsGain, 5000.0f) / 2000.0f);

for (int i = 0; i < FdnDelayLines.Length; i++)

{

uint tempSampleCount = FdnDelayLines[i].CurrentSampleCount + DecayDelays1[i].CurrentSampleCount + DecayDelays2[i].CurrentSampleCount;

for (int i = 0; i < EarlyDelayTime.Length; i++)

{

EarlyDelayTime[i] = sampleCount;

}

}

}

{

public class ReverbState

{

{

// Room

53.953247f, 79.192566f, 116.238770f, 130.615295f,

53.953247f, 79.192566f, 116.238770f, 170.615295f,

};

{

// Room

7f, 9f, 13f, 17f,

7f, 9f, 13f, 17f,

};

{

// Room

0.0f, 3.5f, 2.8f, 3.9f, 2.7f, 13.4f, 7.9f, 8.4f, 9.9f, 12.0f,

// Cathedral

33.1f, 43.3f, 22.8f, 37.9f, 14.9f, 35.3f, 17.9f, 34.2f, 0.0f, 43.3f,

// Disabled

};

{

// Room

0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.68f, 0.68f,

// Cathedral

0.93f, 0.92f, 0.87f, 0.86f, 0.94f, 0.81f, 0.80f, 0.77f, 0.76f, 0.65f,

// Disabled

};

{

// Room

12.5f,

// Cathedral

50.0f,

// Disabled

};

public DelayLine[] FdnDelayLines { get; }

private const int FixedPointPrecision = 14;

{

}

{

}

public ReverbState(ref ReverbParameter parameter, ulong workBuffer, bool isLongSizePreDelaySupported)

for (int i = 0; i < 10; i++)

{

}

if (parameter.ChannelCount == 2)

EarlyGain[5] = EarlyGain[5] * 0.5f;

}

ReadOnlySpan<float> fdnDelayTimes = GetFdnDelayTimesByLateMode(parameter.LateMode);

ReadOnlySpan<float> decayDelayTimes = GetDecayDelayTimesByLateMode(parameter.LateMode);

}

}

}

private const int FilterBankLength = 20;

// Bank0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

private const int Bank0CenterIndex = 9;

private static Array20<float> PrecomputeFilterBank(float offset)

{

return A0 + A1 * MathF.Cos(2 * MathF.PI * x) + A2 * MathF.Cos(4 * MathF.PI * x);

}

for (int i = 0; i < FilterBankLength; i++)

{

{

state.Scale = inputSampleCount switch

{

160 => 1.5f,

};

state.Initialized = true;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

void NextInput(ref UpsamplerBufferState state, float input)

{

state.History[HistoryLength - 1] = input;

}

outputBuffer[i] = state.History[Bank0CenterIndex];

break;

case 1:

break;

case 2:

break;

case 3:

break;

case 4:

break;

case 5:

break;

}

outputBuffer[i] = state.History[Bank0CenterIndex];

break;

case 1:

break;

case 2:

break;

}

outputBuffer[i] = state.History[Bank0CenterIndex];

break;

case 1:

break;

case 2:

NextInput(ref state, inputBuffer[inputBufferIndex++]);

break;

}

}

break;

default:

}

}

}