aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer
diff options
context:
space:
mode:
Diffstat (limited to 'Ryujinx.HLE/HOS/Services/Aud/AudioRenderer')
-rw-r--r--Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs302
-rw-r--r--Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/MemoryPoolState.cs2
-rw-r--r--Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/Resampler.cs82
-rw-r--r--Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/VoiceContext.cs114
4 files changed, 250 insertions, 250 deletions
diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
index 50a87893..0ad193ca 100644
--- a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
+++ b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/IAudioRenderer.cs
@@ -22,33 +22,33 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
//high latency).
private const int MixBufferSamplesCount = 960;
- private Dictionary<int, ServiceProcessRequest> m_Commands;
+ private Dictionary<int, ServiceProcessRequest> _commands;
- public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+ public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => _commands;
- private KEvent UpdateEvent;
+ private KEvent _updateEvent;
- private MemoryManager Memory;
+ private MemoryManager _memory;
- private IAalOutput AudioOut;
+ private IAalOutput _audioOut;
- private AudioRendererParameter Params;
+ private AudioRendererParameter _params;
- private MemoryPoolContext[] MemoryPools;
+ private MemoryPoolContext[] _memoryPools;
- private VoiceContext[] Voices;
+ private VoiceContext[] _voices;
- private int Track;
+ private int _track;
- private PlayState PlayState;
+ private PlayState _playState;
public IAudioRenderer(
- Horizon System,
- MemoryManager Memory,
- IAalOutput AudioOut,
+ Horizon system,
+ MemoryManager memory,
+ IAalOutput audioOut,
AudioRendererParameter Params)
{
- m_Commands = new Dictionary<int, ServiceProcessRequest>()
+ _commands = new Dictionary<int, ServiceProcessRequest>
{
{ 0, GetSampleRate },
{ 1, GetSampleCount },
@@ -60,75 +60,75 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
{ 7, QuerySystemEvent }
};
- UpdateEvent = new KEvent(System);
+ _updateEvent = new KEvent(system);
- this.Memory = Memory;
- this.AudioOut = AudioOut;
- this.Params = Params;
+ _memory = memory;
+ _audioOut = audioOut;
+ _params = Params;
- Track = AudioOut.OpenTrack(
+ _track = audioOut.OpenTrack(
AudioConsts.HostSampleRate,
AudioConsts.HostChannelsCount,
AudioCallback);
- MemoryPools = CreateArray<MemoryPoolContext>(Params.EffectCount + Params.VoiceCount * 4);
+ _memoryPools = CreateArray<MemoryPoolContext>(Params.EffectCount + Params.VoiceCount * 4);
- Voices = CreateArray<VoiceContext>(Params.VoiceCount);
+ _voices = CreateArray<VoiceContext>(Params.VoiceCount);
InitializeAudioOut();
- PlayState = PlayState.Stopped;
+ _playState = PlayState.Stopped;
}
// GetSampleRate() -> u32
- public long GetSampleRate(ServiceCtx Context)
+ public long GetSampleRate(ServiceCtx context)
{
- Context.ResponseData.Write(Params.SampleRate);
+ context.ResponseData.Write(_params.SampleRate);
return 0;
}
// GetSampleCount() -> u32
- public long GetSampleCount(ServiceCtx Context)
+ public long GetSampleCount(ServiceCtx context)
{
- Context.ResponseData.Write(Params.SampleCount);
+ context.ResponseData.Write(_params.SampleCount);
return 0;
}
// GetMixBufferCount() -> u32
- public long GetMixBufferCount(ServiceCtx Context)
+ public long GetMixBufferCount(ServiceCtx context)
{
- Context.ResponseData.Write(Params.MixCount);
+ context.ResponseData.Write(_params.MixCount);
return 0;
}
// GetState() -> u32
- private long GetState(ServiceCtx Context)
+ private long GetState(ServiceCtx context)
{
- Context.ResponseData.Write((int)PlayState);
+ context.ResponseData.Write((int)_playState);
- Logger.PrintStub(LogClass.ServiceAudio, $"Stubbed. Renderer State: {Enum.GetName(typeof(PlayState), PlayState)}");
+ Logger.PrintStub(LogClass.ServiceAudio, $"Stubbed. Renderer State: {Enum.GetName(typeof(PlayState), _playState)}");
return 0;
}
private void AudioCallback()
{
- UpdateEvent.ReadableEvent.Signal();
+ _updateEvent.ReadableEvent.Signal();
}
- private static T[] CreateArray<T>(int Size) where T : new()
+ private static T[] CreateArray<T>(int size) where T : new()
{
- T[] Output = new T[Size];
+ T[] output = new T[size];
- for (int Index = 0; Index < Size; Index++)
+ for (int index = 0; index < size; index++)
{
- Output[Index] = new T();
+ output[index] = new T();
}
- return Output;
+ return output;
}
private void InitializeAudioOut()
@@ -137,258 +137,258 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
AppendMixedBuffer(1);
AppendMixedBuffer(2);
- AudioOut.Start(Track);
+ _audioOut.Start(_track);
}
- public long RequestUpdateAudioRenderer(ServiceCtx Context)
+ public long RequestUpdateAudioRenderer(ServiceCtx context)
{
- long OutputPosition = Context.Request.ReceiveBuff[0].Position;
- long OutputSize = Context.Request.ReceiveBuff[0].Size;
+ long outputPosition = context.Request.ReceiveBuff[0].Position;
+ long outputSize = context.Request.ReceiveBuff[0].Size;
- MemoryHelper.FillWithZeros(Context.Memory, OutputPosition, (int)OutputSize);
+ MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);
- long InputPosition = Context.Request.SendBuff[0].Position;
+ long inputPosition = context.Request.SendBuff[0].Position;
- StructReader Reader = new StructReader(Context.Memory, InputPosition);
- StructWriter Writer = new StructWriter(Context.Memory, OutputPosition);
+ StructReader reader = new StructReader(context.Memory, inputPosition);
+ StructWriter writer = new StructWriter(context.Memory, outputPosition);
- UpdateDataHeader InputHeader = Reader.Read<UpdateDataHeader>();
+ UpdateDataHeader inputHeader = reader.Read<UpdateDataHeader>();
- Reader.Read<BehaviorIn>(InputHeader.BehaviorSize);
+ reader.Read<BehaviorIn>(inputHeader.BehaviorSize);
- MemoryPoolIn[] MemoryPoolsIn = Reader.Read<MemoryPoolIn>(InputHeader.MemoryPoolSize);
+ MemoryPoolIn[] memoryPoolsIn = reader.Read<MemoryPoolIn>(inputHeader.MemoryPoolSize);
- for (int Index = 0; Index < MemoryPoolsIn.Length; Index++)
+ for (int index = 0; index < memoryPoolsIn.Length; index++)
{
- MemoryPoolIn MemoryPool = MemoryPoolsIn[Index];
+ MemoryPoolIn memoryPool = memoryPoolsIn[index];
- if (MemoryPool.State == MemoryPoolState.RequestAttach)
+ if (memoryPool.State == MemoryPoolState.RequestAttach)
{
- MemoryPools[Index].OutStatus.State = MemoryPoolState.Attached;
+ _memoryPools[index].OutStatus.State = MemoryPoolState.Attached;
}
- else if (MemoryPool.State == MemoryPoolState.RequestDetach)
+ else if (memoryPool.State == MemoryPoolState.RequestDetach)
{
- MemoryPools[Index].OutStatus.State = MemoryPoolState.Detached;
+ _memoryPools[index].OutStatus.State = MemoryPoolState.Detached;
}
}
- Reader.Read<VoiceChannelResourceIn>(InputHeader.VoiceResourceSize);
+ reader.Read<VoiceChannelResourceIn>(inputHeader.VoiceResourceSize);
- VoiceIn[] VoicesIn = Reader.Read<VoiceIn>(InputHeader.VoiceSize);
+ VoiceIn[] voicesIn = reader.Read<VoiceIn>(inputHeader.VoiceSize);
- for (int Index = 0; Index < VoicesIn.Length; Index++)
+ for (int index = 0; index < voicesIn.Length; index++)
{
- VoiceIn Voice = VoicesIn[Index];
+ VoiceIn voice = voicesIn[index];
- VoiceContext VoiceCtx = Voices[Index];
+ VoiceContext voiceCtx = _voices[index];
- VoiceCtx.SetAcquireState(Voice.Acquired != 0);
+ voiceCtx.SetAcquireState(voice.Acquired != 0);
- if (Voice.Acquired == 0)
+ if (voice.Acquired == 0)
{
continue;
}
- if (Voice.FirstUpdate != 0)
+ if (voice.FirstUpdate != 0)
{
- VoiceCtx.AdpcmCtx = GetAdpcmDecoderContext(
- Voice.AdpcmCoeffsPosition,
- Voice.AdpcmCoeffsSize);
+ voiceCtx.AdpcmCtx = GetAdpcmDecoderContext(
+ voice.AdpcmCoeffsPosition,
+ voice.AdpcmCoeffsSize);
- VoiceCtx.SampleFormat = Voice.SampleFormat;
- VoiceCtx.SampleRate = Voice.SampleRate;
- VoiceCtx.ChannelsCount = Voice.ChannelsCount;
+ voiceCtx.SampleFormat = voice.SampleFormat;
+ voiceCtx.SampleRate = voice.SampleRate;
+ voiceCtx.ChannelsCount = voice.ChannelsCount;
- VoiceCtx.SetBufferIndex(Voice.BaseWaveBufferIndex);
+ voiceCtx.SetBufferIndex(voice.BaseWaveBufferIndex);
}
- VoiceCtx.WaveBuffers[0] = Voice.WaveBuffer0;
- VoiceCtx.WaveBuffers[1] = Voice.WaveBuffer1;
- VoiceCtx.WaveBuffers[2] = Voice.WaveBuffer2;
- VoiceCtx.WaveBuffers[3] = Voice.WaveBuffer3;
- VoiceCtx.Volume = Voice.Volume;
- VoiceCtx.PlayState = Voice.PlayState;
+ voiceCtx.WaveBuffers[0] = voice.WaveBuffer0;
+ voiceCtx.WaveBuffers[1] = voice.WaveBuffer1;
+ voiceCtx.WaveBuffers[2] = voice.WaveBuffer2;
+ voiceCtx.WaveBuffers[3] = voice.WaveBuffer3;
+ voiceCtx.Volume = voice.Volume;
+ voiceCtx.PlayState = voice.PlayState;
}
UpdateAudio();
- UpdateDataHeader OutputHeader = new UpdateDataHeader();
+ UpdateDataHeader outputHeader = new UpdateDataHeader();
- int UpdateHeaderSize = Marshal.SizeOf<UpdateDataHeader>();
+ int updateHeaderSize = Marshal.SizeOf<UpdateDataHeader>();
- OutputHeader.Revision = IAudioRendererManager.RevMagic;
- OutputHeader.BehaviorSize = 0xb0;
- OutputHeader.MemoryPoolSize = (Params.EffectCount + Params.VoiceCount * 4) * 0x10;
- OutputHeader.VoiceSize = Params.VoiceCount * 0x10;
- OutputHeader.EffectSize = Params.EffectCount * 0x10;
- OutputHeader.SinkSize = Params.SinkCount * 0x20;
- OutputHeader.PerformanceManagerSize = 0x10;
- OutputHeader.TotalSize = UpdateHeaderSize +
- OutputHeader.BehaviorSize +
- OutputHeader.MemoryPoolSize +
- OutputHeader.VoiceSize +
- OutputHeader.EffectSize +
- OutputHeader.SinkSize +
- OutputHeader.PerformanceManagerSize;
+ outputHeader.Revision = IAudioRendererManager.RevMagic;
+ outputHeader.BehaviorSize = 0xb0;
+ outputHeader.MemoryPoolSize = (_params.EffectCount + _params.VoiceCount * 4) * 0x10;
+ outputHeader.VoiceSize = _params.VoiceCount * 0x10;
+ outputHeader.EffectSize = _params.EffectCount * 0x10;
+ outputHeader.SinkSize = _params.SinkCount * 0x20;
+ outputHeader.PerformanceManagerSize = 0x10;
+ outputHeader.TotalSize = updateHeaderSize +
+ outputHeader.BehaviorSize +
+ outputHeader.MemoryPoolSize +
+ outputHeader.VoiceSize +
+ outputHeader.EffectSize +
+ outputHeader.SinkSize +
+ outputHeader.PerformanceManagerSize;
- Writer.Write(OutputHeader);
+ writer.Write(outputHeader);
- foreach (MemoryPoolContext MemoryPool in MemoryPools)
+ foreach (MemoryPoolContext memoryPool in _memoryPools)
{
- Writer.Write(MemoryPool.OutStatus);
+ writer.Write(memoryPool.OutStatus);
}
- foreach (VoiceContext Voice in Voices)
+ foreach (VoiceContext voice in _voices)
{
- Writer.Write(Voice.OutStatus);
+ writer.Write(voice.OutStatus);
}
return 0;
}
- public long StartAudioRenderer(ServiceCtx Context)
+ public long StartAudioRenderer(ServiceCtx context)
{
Logger.PrintStub(LogClass.ServiceAudio, "Stubbed.");
- PlayState = PlayState.Playing;
+ _playState = PlayState.Playing;
return 0;
}
- public long StopAudioRenderer(ServiceCtx Context)
+ public long StopAudioRenderer(ServiceCtx context)
{
Logger.PrintStub(LogClass.ServiceAudio, "Stubbed.");
- PlayState = PlayState.Stopped;
+ _playState = PlayState.Stopped;
return 0;
}
- public long QuerySystemEvent(ServiceCtx Context)
+ public long QuerySystemEvent(ServiceCtx context)
{
- if (Context.Process.HandleTable.GenerateHandle(UpdateEvent.ReadableEvent, out int Handle) != KernelResult.Success)
+ if (context.Process.HandleTable.GenerateHandle(_updateEvent.ReadableEvent, out int handle) != KernelResult.Success)
{
throw new InvalidOperationException("Out of handles!");
}
- Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+ context.Response.HandleDesc = IpcHandleDesc.MakeCopy(handle);
return 0;
}
- private AdpcmDecoderContext GetAdpcmDecoderContext(long Position, long Size)
+ private AdpcmDecoderContext GetAdpcmDecoderContext(long position, long size)
{
- if (Size == 0)
+ if (size == 0)
{
return null;
}
- AdpcmDecoderContext Context = new AdpcmDecoderContext();
+ AdpcmDecoderContext context = new AdpcmDecoderContext();
- Context.Coefficients = new short[Size >> 1];
+ context.Coefficients = new short[size >> 1];
- for (int Offset = 0; Offset < Size; Offset += 2)
+ for (int offset = 0; offset < size; offset += 2)
{
- Context.Coefficients[Offset >> 1] = Memory.ReadInt16(Position + Offset);
+ context.Coefficients[offset >> 1] = _memory.ReadInt16(position + offset);
}
- return Context;
+ return context;
}
private void UpdateAudio()
{
- long[] Released = AudioOut.GetReleasedBuffers(Track, 2);
+ long[] released = _audioOut.GetReleasedBuffers(_track, 2);
- for (int Index = 0; Index < Released.Length; Index++)
+ for (int index = 0; index < released.Length; index++)
{
- AppendMixedBuffer(Released[Index]);
+ AppendMixedBuffer(released[index]);
}
}
- private unsafe void AppendMixedBuffer(long Tag)
+ private void AppendMixedBuffer(long tag)
{
- int[] MixBuffer = new int[MixBufferSamplesCount * AudioConsts.HostChannelsCount];
+ int[] mixBuffer = new int[MixBufferSamplesCount * AudioConsts.HostChannelsCount];
- foreach (VoiceContext Voice in Voices)
+ foreach (VoiceContext voice in _voices)
{
- if (!Voice.Playing)
+ if (!voice.Playing)
{
continue;
}
- int OutOffset = 0;
- int PendingSamples = MixBufferSamplesCount;
- float Volume = Voice.Volume;
+ int outOffset = 0;
+ int pendingSamples = MixBufferSamplesCount;
+ float volume = voice.Volume;
- while (PendingSamples > 0)
+ while (pendingSamples > 0)
{
- int[] Samples = Voice.GetBufferData(Memory, PendingSamples, out int ReturnedSamples);
+ int[] samples = voice.GetBufferData(_memory, pendingSamples, out int returnedSamples);
- if (ReturnedSamples == 0)
+ if (returnedSamples == 0)
{
break;
}
- PendingSamples -= ReturnedSamples;
+ pendingSamples -= returnedSamples;
- for (int Offset = 0; Offset < Samples.Length; Offset++)
+ for (int offset = 0; offset < samples.Length; offset++)
{
- MixBuffer[OutOffset++] += (int)(Samples[Offset] * Voice.Volume);
+ mixBuffer[outOffset++] += (int)(samples[offset] * voice.Volume);
}
}
}
- AudioOut.AppendBuffer(Track, Tag, GetFinalBuffer(MixBuffer));
+ _audioOut.AppendBuffer(_track, tag, GetFinalBuffer(mixBuffer));
}
- private unsafe static short[] GetFinalBuffer(int[] Buffer)
+ private unsafe static short[] GetFinalBuffer(int[] buffer)
{
- short[] Output = new short[Buffer.Length];
+ short[] output = new short[buffer.Length];
- int Offset = 0;
+ int offset = 0;
// Perform Saturation using SSE2 if supported
if (Sse2.IsSupported)
{
- fixed (int* inptr = Buffer)
- fixed (short* outptr = Output)
+ fixed (int* inptr = buffer)
+ fixed (short* outptr = output)
{
- for (; Offset + 32 <= Buffer.Length; Offset += 32)
+ for (; offset + 32 <= buffer.Length; offset += 32)
{
// Unroll the loop a little to ensure the CPU pipeline
// is always full.
- Vector128<int> block1A = Sse2.LoadVector128(inptr + Offset + 0);
- Vector128<int> block1B = Sse2.LoadVector128(inptr + Offset + 4);
+ Vector128<int> block1A = Sse2.LoadVector128(inptr + offset + 0);
+ Vector128<int> block1B = Sse2.LoadVector128(inptr + offset + 4);
- Vector128<int> block2A = Sse2.LoadVector128(inptr + Offset + 8);
- Vector128<int> block2B = Sse2.LoadVector128(inptr + Offset + 12);
+ Vector128<int> block2A = Sse2.LoadVector128(inptr + offset + 8);
+ Vector128<int> block2B = Sse2.LoadVector128(inptr + offset + 12);
- Vector128<int> block3A = Sse2.LoadVector128(inptr + Offset + 16);
- Vector128<int> block3B = Sse2.LoadVector128(inptr + Offset + 20);
+ Vector128<int> block3A = Sse2.LoadVector128(inptr + offset + 16);
+ Vector128<int> block3B = Sse2.LoadVector128(inptr + offset + 20);
- Vector128<int> block4A = Sse2.LoadVector128(inptr + Offset + 24);
- Vector128<int> block4B = Sse2.LoadVector128(inptr + Offset + 28);
+ Vector128<int> block4A = Sse2.LoadVector128(inptr + offset + 24);
+ Vector128<int> block4B = Sse2.LoadVector128(inptr + offset + 28);
Vector128<short> output1 = Sse2.PackSignedSaturate(block1A, block1B);
Vector128<short> output2 = Sse2.PackSignedSaturate(block2A, block2B);
Vector128<short> output3 = Sse2.PackSignedSaturate(block3A, block3B);
Vector128<short> output4 = Sse2.PackSignedSaturate(block4A, block4B);
- Sse2.Store(outptr + Offset + 0, output1);
- Sse2.Store(outptr + Offset + 8, output2);
- Sse2.Store(outptr + Offset + 16, output3);
- Sse2.Store(outptr + Offset + 24, output4);
+ Sse2.Store(outptr + offset + 0, output1);
+ Sse2.Store(outptr + offset + 8, output2);
+ Sse2.Store(outptr + offset + 16, output3);
+ Sse2.Store(outptr + offset + 24, output4);
}
}
}
// Process left overs
- for (; Offset < Buffer.Length; Offset++)
+ for (; offset < buffer.Length; offset++)
{
- Output[Offset] = DspUtils.Saturate(Buffer[Offset]);
+ output[offset] = DspUtils.Saturate(buffer[offset]);
}
- return Output;
+ return output;
}
public void Dispose()
@@ -396,11 +396,11 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
Dispose(true);
}
- protected virtual void Dispose(bool Disposing)
+ protected virtual void Dispose(bool disposing)
{
- if (Disposing)
+ if (disposing)
{
- AudioOut.CloseTrack(Track);
+ _audioOut.CloseTrack(_track);
}
}
}
diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/MemoryPoolState.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/MemoryPoolState.cs
index 6baf507c..6a37c1af 100644
--- a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/MemoryPoolState.cs
+++ b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/MemoryPoolState.cs
@@ -1,6 +1,6 @@
namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
{
- enum MemoryPoolState : int
+ enum MemoryPoolState
{
Invalid = 0,
Unknown = 1,
diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/Resampler.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/Resampler.cs
index baa0bc62..9714f6d8 100644
--- a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/Resampler.cs
+++ b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/Resampler.cs
@@ -5,7 +5,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
static class Resampler
{
#region "LookUp Tables"
- private static short[] CurveLut0 = new short[]
+ private static short[] _curveLut0 = new short[]
{
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,
@@ -41,7 +41,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
22, 7093, 19412, 6239, 15, 6968, 19419, 6359, 9, 6845, 19424, 6479, 3, 6722, 19426, 6600
};
- private static short[] CurveLut1 = new short[]
+ private static short[] _curveLut1 = new short[]
{
-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,
@@ -77,7 +77,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
-36, 512, 32586, -450, -26, 359, 32613, -328, -15, 212, 32630, -200, -5, 69, 32639, -68
};
- private static short[] CurveLut2 = new short[]
+ private static short[] _curveLut2 = new short[]
{
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,
@@ -115,77 +115,77 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
#endregion
public static int[] Resample2Ch(
- int[] Buffer,
- int SrcSampleRate,
- int DstSampleRate,
- int SamplesCount,
- ref int FracPart)
+ int[] buffer,
+ int srcSampleRate,
+ int dstSampleRate,
+ int samplesCount,
+ ref int fracPart)
{
- if (Buffer == null)
+ if (buffer == null)
{
- throw new ArgumentNullException(nameof(Buffer));
+ throw new ArgumentNullException(nameof(buffer));
}
- if (SrcSampleRate <= 0)
+ if (srcSampleRate <= 0)
{
- throw new ArgumentOutOfRangeException(nameof(SrcSampleRate));
+ throw new ArgumentOutOfRangeException(nameof(srcSampleRate));
}
- if (DstSampleRate <= 0)
+ if (dstSampleRate <= 0)
{
- throw new ArgumentOutOfRangeException(nameof(DstSampleRate));
+ throw new ArgumentOutOfRangeException(nameof(dstSampleRate));
}
- double Ratio = (double)SrcSampleRate / DstSampleRate;
+ double ratio = (double)srcSampleRate / dstSampleRate;
- int NewSamplesCount = (int)(SamplesCount / Ratio);
+ int newSamplesCount = (int)(samplesCount / ratio);
- int Step = (int)(Ratio * 0x8000);
+ int step = (int)(ratio * 0x8000);
- int[] Output = new int[NewSamplesCount * 2];
+ int[] output = new int[newSamplesCount * 2];
- short[] Lut;
+ short[] lut;
- if (Step > 0xaaaa)
+ if (step > 0xaaaa)
{
- Lut = CurveLut0;
+ lut = _curveLut0;
}
- else if (Step <= 0x8000)
+ else if (step <= 0x8000)
{
- Lut = CurveLut1;
+ lut = _curveLut1;
}
else
{
- Lut = CurveLut2;
+ lut = _curveLut2;
}
- int InOffs = 0;
+ int inOffs = 0;
- for (int OutOffs = 0; OutOffs < Output.Length; OutOffs += 2)
+ for (int outOffs = 0; outOffs < output.Length; outOffs += 2)
{
- int LutIndex = (FracPart >> 8) * 4;
+ int lutIndex = (fracPart >> 8) * 4;
- int Sample0 = Buffer[(InOffs + 0) * 2 + 0] * Lut[LutIndex + 0] +
- Buffer[(InOffs + 1) * 2 + 0] * Lut[LutIndex + 1] +
- Buffer[(InOffs + 2) * 2 + 0] * Lut[LutIndex + 2] +
- Buffer[(InOffs + 3) * 2 + 0] * Lut[LutIndex + 3];
+ int sample0 = buffer[(inOffs + 0) * 2 + 0] * lut[lutIndex + 0] +
+ buffer[(inOffs + 1) * 2 + 0] * lut[lutIndex + 1] +
+ buffer[(inOffs + 2) * 2 + 0] * lut[lutIndex + 2] +
+ buffer[(inOffs + 3) * 2 + 0] * lut[lutIndex + 3];
- int Sample1 = Buffer[(InOffs + 0) * 2 + 1] * Lut[LutIndex + 0] +
- Buffer[(InOffs + 1) * 2 + 1] * Lut[LutIndex + 1] +
- Buffer[(InOffs + 2) * 2 + 1] * Lut[LutIndex + 2] +
- Buffer[(InOffs + 3) * 2 + 1] * Lut[LutIndex + 3];
+ int sample1 = buffer[(inOffs + 0) * 2 + 1] * lut[lutIndex + 0] +
+ buffer[(inOffs + 1) * 2 + 1] * lut[lutIndex + 1] +
+ buffer[(inOffs + 2) * 2 + 1] * lut[lutIndex + 2] +
+ buffer[(inOffs + 3) * 2 + 1] * lut[lutIndex + 3];
- int NewOffset = FracPart + Step;
+ int newOffset = fracPart + step;
- InOffs += NewOffset >> 15;
+ inOffs += newOffset >> 15;
- FracPart = NewOffset & 0x7fff;
+ fracPart = newOffset & 0x7fff;
- Output[OutOffs + 0] = Sample0 >> 15;
- Output[OutOffs + 1] = Sample1 >> 15;
+ output[outOffs + 0] = sample0 >> 15;
+ output[outOffs + 1] = sample1 >> 15;
}
- return Output;
+ return output;
}
}
} \ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/VoiceContext.cs b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/VoiceContext.cs
index 7d6e1c58..a877081d 100644
--- a/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/VoiceContext.cs
+++ b/Ryujinx.HLE/HOS/Services/Aud/AudioRenderer/VoiceContext.cs
@@ -6,13 +6,13 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
{
class VoiceContext
{
- private bool Acquired;
- private bool BufferReload;
+ private bool _acquired;
+ private bool _bufferReload;
- private int ResamplerFracPart;
+ private int _resamplerFracPart;
- private int BufferIndex;
- private int Offset;
+ private int _bufferIndex;
+ private int _offset;
public int SampleRate;
public int ChannelsCount;
@@ -29,138 +29,138 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
public VoiceOut OutStatus;
- private int[] Samples;
+ private int[] _samples;
- public bool Playing => Acquired && PlayState == PlayState.Playing;
+ public bool Playing => _acquired && PlayState == PlayState.Playing;
public VoiceContext()
{
WaveBuffers = new WaveBuffer[4];
}
- public void SetAcquireState(bool NewState)
+ public void SetAcquireState(bool newState)
{
- if (Acquired && !NewState)
+ if (_acquired && !newState)
{
//Release.
Reset();
}
- Acquired = NewState;
+ _acquired = newState;
}
private void Reset()
{
- BufferReload = true;
+ _bufferReload = true;
- BufferIndex = 0;
- Offset = 0;
+ _bufferIndex = 0;
+ _offset = 0;
OutStatus.PlayedSamplesCount = 0;
OutStatus.PlayedWaveBuffersCount = 0;
OutStatus.VoiceDropsCount = 0;
}
- public int[] GetBufferData(MemoryManager Memory, int MaxSamples, out int SamplesCount)
+ public int[] GetBufferData(MemoryManager memory, int maxSamples, out int samplesCount)
{
if (!Playing)
{
- SamplesCount = 0;
+ samplesCount = 0;
return null;
}
- if (BufferReload)
+ if (_bufferReload)
{
- BufferReload = false;
+ _bufferReload = false;
- UpdateBuffer(Memory);
+ UpdateBuffer(memory);
}
- WaveBuffer Wb = WaveBuffers[BufferIndex];
+ WaveBuffer wb = WaveBuffers[_bufferIndex];
- int MaxSize = Samples.Length - Offset;
+ int maxSize = _samples.Length - _offset;
- int Size = MaxSamples * AudioConsts.HostChannelsCount;
+ int size = maxSamples * AudioConsts.HostChannelsCount;
- if (Size > MaxSize)
+ if (size > maxSize)
{
- Size = MaxSize;
+ size = maxSize;
}
- int[] Output = new int[Size];
+ int[] output = new int[size];
- Array.Copy(Samples, Offset, Output, 0, Size);
+ Array.Copy(_samples, _offset, output, 0, size);
- SamplesCount = Size / AudioConsts.HostChannelsCount;
+ samplesCount = size / AudioConsts.HostChannelsCount;
- OutStatus.PlayedSamplesCount += SamplesCount;
+ OutStatus.PlayedSamplesCount += samplesCount;
- Offset += Size;
+ _offset += size;
- if (Offset == Samples.Length)
+ if (_offset == _samples.Length)
{
- Offset = 0;
+ _offset = 0;
- if (Wb.Looping == 0)
+ if (wb.Looping == 0)
{
- SetBufferIndex((BufferIndex + 1) & 3);
+ SetBufferIndex((_bufferIndex + 1) & 3);
}
OutStatus.PlayedWaveBuffersCount++;
- if (Wb.LastBuffer != 0)
+ if (wb.LastBuffer != 0)
{
PlayState = PlayState.Paused;
}
}
- return Output;
+ return output;
}
- private void UpdateBuffer(MemoryManager Memory)
+ private void UpdateBuffer(MemoryManager memory)
{
//TODO: Implement conversion for formats other
//than interleaved stereo (2 channels).
//As of now, it assumes that HostChannelsCount == 2.
- WaveBuffer Wb = WaveBuffers[BufferIndex];
+ WaveBuffer wb = WaveBuffers[_bufferIndex];
- if (Wb.Position == 0)
+ if (wb.Position == 0)
{
- Samples = new int[0];
+ _samples = new int[0];
return;
}
if (SampleFormat == SampleFormat.PcmInt16)
{
- int SamplesCount = (int)(Wb.Size / (sizeof(short) * ChannelsCount));
+ int samplesCount = (int)(wb.Size / (sizeof(short) * ChannelsCount));
- Samples = new int[SamplesCount * AudioConsts.HostChannelsCount];
+ _samples = new int[samplesCount * AudioConsts.HostChannelsCount];
if (ChannelsCount == 1)
{
- for (int Index = 0; Index < SamplesCount; Index++)
+ for (int index = 0; index < samplesCount; index++)
{
- short Sample = Memory.ReadInt16(Wb.Position + Index * 2);
+ short sample = memory.ReadInt16(wb.Position + index * 2);
- Samples[Index * 2 + 0] = Sample;
- Samples[Index * 2 + 1] = Sample;
+ _samples[index * 2 + 0] = sample;
+ _samples[index * 2 + 1] = sample;
}
}
else
{
- for (int Index = 0; Index < SamplesCount * 2; Index++)
+ for (int index = 0; index < samplesCount * 2; index++)
{
- Samples[Index] = Memory.ReadInt16(Wb.Position + Index * 2);
+ _samples[index] = memory.ReadInt16(wb.Position + index * 2);
}
}
}
else if (SampleFormat == SampleFormat.Adpcm)
{
- byte[] Buffer = Memory.ReadBytes(Wb.Position, Wb.Size);
+ byte[] buffer = memory.ReadBytes(wb.Position, wb.Size);
- Samples = AdpcmDecoder.Decode(Buffer, AdpcmCtx);
+ _samples = AdpcmDecoder.Decode(buffer, AdpcmCtx);
}
else
{
@@ -172,24 +172,24 @@ namespace Ryujinx.HLE.HOS.Services.Aud.AudioRenderer
//TODO: We should keep the frames being discarded (see the 4 below)
//on a buffer and include it on the next samples buffer, to allow
//the resampler to do seamless interpolation between wave buffers.
- int SamplesCount = Samples.Length / AudioConsts.HostChannelsCount;
+ int samplesCount = _samples.Length / AudioConsts.HostChannelsCount;
- SamplesCount = Math.Max(SamplesCount - 4, 0);
+ samplesCount = Math.Max(samplesCount - 4, 0);
- Samples = Resampler.Resample2Ch(
- Samples,
+ _samples = Resampler.Resample2Ch(
+ _samples,
SampleRate,
AudioConsts.HostSampleRate,
- SamplesCount,
- ref ResamplerFracPart);
+ samplesCount,
+ ref _resamplerFracPart);
}
}
- public void SetBufferIndex(int Index)
+ public void SetBufferIndex(int index)
{
- BufferIndex = Index & 3;
+ _bufferIndex = index & 3;
- BufferReload = true;
+ _bufferReload = true;
}
}
}