aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Ryujinx.Audio/IAalOutput.cs5
-rw-r--r--Ryujinx.Audio/Renderers/DummyAudioOut.cs72
-rw-r--r--Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs375
-rw-r--r--Ryujinx.Audio/Renderers/OpenAL/OpenALAudioTrack.cs142
-rw-r--r--Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs161
-rw-r--r--Ryujinx.HLE/HOS/Services/Audio/AudioOutManager/IAudioOut.cs26
6 files changed, 469 insertions, 312 deletions
diff --git a/Ryujinx.Audio/IAalOutput.cs b/Ryujinx.Audio/IAalOutput.cs
index 119fc234..489f9002 100644
--- a/Ryujinx.Audio/IAalOutput.cs
+++ b/Ryujinx.Audio/IAalOutput.cs
@@ -15,8 +15,13 @@ namespace Ryujinx.Audio
void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct;
void Start(int trackId);
+
void Stop(int trackId);
+ float GetVolume();
+
+ void SetVolume(float volume);
+
PlaybackState GetState(int trackId);
}
} \ No newline at end of file
diff --git a/Ryujinx.Audio/Renderers/DummyAudioOut.cs b/Ryujinx.Audio/Renderers/DummyAudioOut.cs
index 56ae5d4f..10943ae6 100644
--- a/Ryujinx.Audio/Renderers/DummyAudioOut.cs
+++ b/Ryujinx.Audio/Renderers/DummyAudioOut.cs
@@ -1,4 +1,5 @@
-using System.Collections.Concurrent;
+using System;
+using System.Collections.Concurrent;
using System.Collections.Generic;
namespace Ryujinx.Audio
@@ -8,17 +9,18 @@ namespace Ryujinx.Audio
/// </summary>
public class DummyAudioOut : IAalOutput
{
- private int lastTrackId = 1;
+ private int _lastTrackId = 1;
+ private float _volume = 1.0f;
- private ConcurrentQueue<int> m_TrackIds;
- private ConcurrentQueue<long> m_Buffers;
- private ConcurrentDictionary<int, ReleaseCallback> m_ReleaseCallbacks;
+ private ConcurrentQueue<int> _trackIds;
+ private ConcurrentQueue<long> _buffers;
+ private ConcurrentDictionary<int, ReleaseCallback> _releaseCallbacks;
public DummyAudioOut()
{
- m_Buffers = new ConcurrentQueue<long>();
- m_TrackIds = new ConcurrentQueue<int>();
- m_ReleaseCallbacks = new ConcurrentDictionary<int, ReleaseCallback>();
+ _buffers = new ConcurrentQueue<long>();
+ _trackIds = new ConcurrentQueue<int>();
+ _releaseCallbacks = new ConcurrentDictionary<int, ReleaseCallback>();
}
/// <summary>
@@ -30,38 +32,23 @@ namespace Ryujinx.Audio
public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
{
- int trackId;
-
- if (!m_TrackIds.TryDequeue(out trackId))
+ if (!_trackIds.TryDequeue(out int trackId))
{
- trackId = ++lastTrackId;
+ trackId = ++_lastTrackId;
}
- m_ReleaseCallbacks[trackId] = callback;
+ _releaseCallbacks[trackId] = callback;
return trackId;
}
public void CloseTrack(int trackId)
{
- m_TrackIds.Enqueue(trackId);
- m_ReleaseCallbacks.Remove(trackId, out _);
+ _trackIds.Enqueue(trackId);
+ _releaseCallbacks.Remove(trackId, out _);
}
- public void Start(int trackId) { }
-
- public void Stop(int trackId) { }
-
- public void AppendBuffer<T>(int trackID, long bufferTag, T[] buffer)
- where T : struct
- {
- m_Buffers.Enqueue(bufferTag);
-
- if (m_ReleaseCallbacks.TryGetValue(trackID, out var callback))
- {
- callback?.Invoke();
- }
- }
+ public bool ContainsBuffer(int trackID, long bufferTag) => false;
public long[] GetReleasedBuffers(int trackId, int maxCount)
{
@@ -69,7 +56,7 @@ namespace Ryujinx.Audio
for (int i = 0; i < maxCount; i++)
{
- if (!m_Buffers.TryDequeue(out long tag))
+ if (!_buffers.TryDequeue(out long tag))
{
break;
}
@@ -80,11 +67,30 @@ namespace Ryujinx.Audio
return bufferTags.ToArray();
}
- public bool ContainsBuffer(int trackID, long bufferTag) => false;
+ public void AppendBuffer<T>(int trackID, long bufferTag, T[] buffer) where T : struct
+ {
+ _buffers.Enqueue(bufferTag);
+
+ if (_releaseCallbacks.TryGetValue(trackID, out var callback))
+ {
+ callback?.Invoke();
+ }
+ }
+
+ public void Start(int trackId) { }
+
+ public void Stop(int trackId) { }
+
+ public float GetVolume() => _volume;
+
+ public void SetVolume(float volume)
+ {
+ _volume = volume;
+ }
public void Dispose()
{
- m_Buffers.Clear();
+ _buffers.Clear();
}
}
-}
+} \ No newline at end of file
diff --git a/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
index 6e085eed..69f36a4d 100644
--- a/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
+++ b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioOut.cs
@@ -2,7 +2,6 @@ using OpenTK.Audio;
using OpenTK.Audio.OpenAL;
using System;
using System.Collections.Concurrent;
-using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
@@ -13,174 +12,43 @@ namespace Ryujinx.Audio
/// </summary>
public class OpenALAudioOut : IAalOutput, IDisposable
{
+ /// <summary>
+ /// The maximum amount of tracks we can issue simultaneously
+ /// </summary>
private const int MaxTracks = 256;
- private const int MaxReleased = 32;
-
- private AudioContext Context;
-
- private class Track : IDisposable
- {
- public int SourceId { get; private set; }
-
- public int SampleRate { get; private set; }
-
- public ALFormat Format { get; private set; }
-
- private ReleaseCallback Callback;
-
- public PlaybackState State { get; set; }
-
- private ConcurrentDictionary<long, int> Buffers;
-
- private Queue<long> QueuedTagsQueue;
-
- private Queue<long> ReleasedTagsQueue;
-
- private bool Disposed;
-
- public Track(int SampleRate, ALFormat Format, ReleaseCallback Callback)
- {
- this.SampleRate = SampleRate;
- this.Format = Format;
- this.Callback = Callback;
-
- State = PlaybackState.Stopped;
-
- SourceId = AL.GenSource();
-
- Buffers = new ConcurrentDictionary<long, int>();
-
- QueuedTagsQueue = new Queue<long>();
-
- ReleasedTagsQueue = new Queue<long>();
- }
-
- public bool ContainsBuffer(long Tag)
- {
- foreach (long QueuedTag in QueuedTagsQueue)
- {
- if (QueuedTag == Tag)
- {
- return true;
- }
- }
-
- return false;
- }
-
- public long[] GetReleasedBuffers(int Count)
- {
- AL.GetSource(SourceId, ALGetSourcei.BuffersProcessed, out int ReleasedCount);
-
- ReleasedCount += ReleasedTagsQueue.Count;
-
- if (Count > ReleasedCount)
- {
- Count = ReleasedCount;
- }
-
- List<long> Tags = new List<long>();
-
- while (Count-- > 0 && ReleasedTagsQueue.TryDequeue(out long Tag))
- {
- Tags.Add(Tag);
- }
-
- while (Count-- > 0 && QueuedTagsQueue.TryDequeue(out long Tag))
- {
- AL.SourceUnqueueBuffers(SourceId, 1);
-
- Tags.Add(Tag);
- }
-
- return Tags.ToArray();
- }
-
- public int AppendBuffer(long Tag)
- {
- if (Disposed)
- {
- throw new ObjectDisposedException(nameof(Track));
- }
-
- int Id = AL.GenBuffer();
-
- Buffers.AddOrUpdate(Tag, Id, (Key, OldId) =>
- {
- AL.DeleteBuffer(OldId);
-
- return Id;
- });
-
- QueuedTagsQueue.Enqueue(Tag);
-
- return Id;
- }
-
- public void CallReleaseCallbackIfNeeded()
- {
- AL.GetSource(SourceId, ALGetSourcei.BuffersProcessed, out int ReleasedCount);
-
- if (ReleasedCount > 0)
- {
- // If we signal, then we also need to have released buffers available
- // to return when GetReleasedBuffers is called.
- // If playback needs to be re-started due to all buffers being processed,
- // then OpenAL zeros the counts (ReleasedCount), so we keep it on the queue.
- while (ReleasedCount-- > 0 && QueuedTagsQueue.TryDequeue(out long Tag))
- {
- AL.SourceUnqueueBuffers(SourceId, 1);
-
- ReleasedTagsQueue.Enqueue(Tag);
- }
-
- Callback();
- }
- }
-
- public void Dispose()
- {
- Dispose(true);
- }
-
- protected virtual void Dispose(bool Disposing)
- {
- if (Disposing && !Disposed)
- {
- Disposed = true;
-
- AL.DeleteSource(SourceId);
-
- foreach (int Id in Buffers.Values)
- {
- AL.DeleteBuffer(Id);
- }
- }
- }
- }
-
- private ConcurrentDictionary<int, Track> Tracks;
-
- private Thread AudioPollerThread;
-
- private bool KeepPolling;
+ /// <summary>
+ /// The <see cref="OpenTK.Audio"/> audio context
+ /// </summary>
+ private AudioContext _context;
- public OpenALAudioOut()
- {
- Context = new AudioContext();
+ /// <summary>
+ /// An object pool containing <see cref="OpenALAudioTrack"/> objects
+ /// </summary>
+ private ConcurrentDictionary<int, OpenALAudioTrack> _tracks;
- Tracks = new ConcurrentDictionary<int, Track>();
+ /// <summary>
+ /// True if the thread need to keep polling
+ /// </summary>
+ private bool _keepPolling;
- KeepPolling = true;
+ /// <summary>
+ /// The poller thread audio context
+ /// </summary>
+ private Thread _audioPollerThread;
- AudioPollerThread = new Thread(AudioPollerWork);
+ /// <summary>
+ /// The volume of audio renderer
+ /// </summary>
+ private float _volume = 1.0f;
- AudioPollerThread.Start();
- }
+ /// <summary>
+ /// True if the volume of audio renderer have changed
+ /// </summary>
+ private bool _volumeChanged;
/// <summary>
- /// True if OpenAL is supported on the device.
+ /// True if OpenAL is supported on the device
/// </summary>
public static bool IsSupported
{
@@ -197,157 +65,232 @@ namespace Ryujinx.Audio
}
}
+ public OpenALAudioOut()
+ {
+ _context = new AudioContext();
+ _tracks = new ConcurrentDictionary<int, OpenALAudioTrack>();
+ _keepPolling = true;
+ _audioPollerThread = new Thread(AudioPollerWork);
+
+ _audioPollerThread.Start();
+ }
+
private void AudioPollerWork()
{
do
{
- foreach (Track Td in Tracks.Values)
+ foreach (OpenALAudioTrack track in _tracks.Values)
{
- lock (Td)
+ lock (track)
{
- Td.CallReleaseCallbackIfNeeded();
+ track.CallReleaseCallbackIfNeeded();
}
}
// If it's not slept it will waste cycles.
Thread.Sleep(10);
}
- while (KeepPolling);
+ while (_keepPolling);
- foreach (Track Td in Tracks.Values)
+ foreach (OpenALAudioTrack track in _tracks.Values)
{
- Td.Dispose();
+ track.Dispose();
}
- Tracks.Clear();
+ _tracks.Clear();
}
- public int OpenTrack(int SampleRate, int Channels, ReleaseCallback Callback)
+ /// <summary>
+ /// Creates a new audio track with the specified parameters
+ /// </summary>
+ /// <param name="sampleRate">The requested sample rate</param>
+ /// <param name="channels">The requested channels</param>
+ /// <param name="callback">A <see cref="ReleaseCallback" /> that represents the delegate to invoke when a buffer has been released by the audio track</param>
+ public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
{
- Track Td = new Track(SampleRate, GetALFormat(Channels), Callback);
+ OpenALAudioTrack track = new OpenALAudioTrack(sampleRate, GetALFormat(channels), callback);
- for (int Id = 0; Id < MaxTracks; Id++)
+ for (int id = 0; id < MaxTracks; id++)
{
- if (Tracks.TryAdd(Id, Td))
+ if (_tracks.TryAdd(id, track))
{
- return Id;
+ return id;
}
}
return -1;
}
- private ALFormat GetALFormat(int Channels)
+ private ALFormat GetALFormat(int channels)
{
- switch (Channels)
+ switch (channels)
{
case 1: return ALFormat.Mono16;
case 2: return ALFormat.Stereo16;
case 6: return ALFormat.Multi51Chn16Ext;
}
- throw new ArgumentOutOfRangeException(nameof(Channels));
+ throw new ArgumentOutOfRangeException(nameof(channels));
}
- public void CloseTrack(int Track)
+ /// <summary>
+ /// Stops playback and closes the track specified by <paramref name="trackId"/>
+ /// </summary>
+ /// <param name="trackId">The ID of the track to close</param>
+ public void CloseTrack(int trackId)
{
- if (Tracks.TryRemove(Track, out Track Td))
+ if (_tracks.TryRemove(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- Td.Dispose();
+ track.Dispose();
}
}
}
- public bool ContainsBuffer(int Track, long Tag)
+ /// <summary>
+ /// Returns a value indicating whether the specified buffer is currently reserved by the specified track
+ /// </summary>
+ /// <param name="trackId">The track to check</param>
+ /// <param name="bufferTag">The buffer tag to check</param>
+ public bool ContainsBuffer(int trackId, long bufferTag)
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- return Td.ContainsBuffer(Tag);
+ return track.ContainsBuffer(bufferTag);
}
}
return false;
}
- public long[] GetReleasedBuffers(int Track, int MaxCount)
+ /// <summary>
+ /// Gets a list of buffer tags the specified track is no longer reserving
+ /// </summary>
+ /// <param name="trackId">The track to retrieve buffer tags from</param>
+ /// <param name="maxCount">The maximum amount of buffer tags to retrieve</param>
+ /// <returns>Buffers released by the specified track</returns>
+ public long[] GetReleasedBuffers(int trackId, int maxCount)
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- return Td.GetReleasedBuffers(MaxCount);
+ return track.GetReleasedBuffers(maxCount);
}
}
return null;
}
- public void AppendBuffer<T>(int Track, long Tag, T[] Buffer) where T : struct
+ /// <summary>
+ /// Appends an audio buffer to the specified track
+ /// </summary>
+ /// <typeparam name="T">The sample type of the buffer</typeparam>
+ /// <param name="trackId">The track to append the buffer to</param>
+ /// <param name="bufferTag">The internal tag of the buffer</param>
+ /// <param name="buffer">The buffer to append to the track</param>
+ public void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- int BufferId = Td.AppendBuffer(Tag);
+ int bufferId = track.AppendBuffer(bufferTag);
- int Size = Buffer.Length * Marshal.SizeOf<T>();
+ int size = buffer.Length * Marshal.SizeOf<T>();
- AL.BufferData<T>(BufferId, Td.Format, Buffer, Size, Td.SampleRate);
+ AL.BufferData(bufferId, track.Format, buffer, size, track.SampleRate);
- AL.SourceQueueBuffer(Td.SourceId, BufferId);
+ AL.SourceQueueBuffer(track.SourceId, bufferId);
- StartPlaybackIfNeeded(Td);
+ StartPlaybackIfNeeded(track);
}
}
}
- public void Start(int Track)
+ /// <summary>
+ /// Starts playback
+ /// </summary>
+ /// <param name="trackId">The ID of the track to start playback on</param>
+ public void Start(int trackId)
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- Td.State = PlaybackState.Playing;
+ track.State = PlaybackState.Playing;
- StartPlaybackIfNeeded(Td);
+ StartPlaybackIfNeeded(track);
}
}
}
- private void StartPlaybackIfNeeded(Track Td)
+ private void StartPlaybackIfNeeded(OpenALAudioTrack track)
{
- AL.GetSource(Td.SourceId, ALGetSourcei.SourceState, out int StateInt);
+ AL.GetSource(track.SourceId, ALGetSourcei.SourceState, out int stateInt);
- ALSourceState State = (ALSourceState)StateInt;
+ ALSourceState State = (ALSourceState)stateInt;
- if (State != ALSourceState.Playing && Td.State == PlaybackState.Playing)
+ if (State != ALSourceState.Playing && track.State == PlaybackState.Playing)
{
- AL.SourcePlay(Td.SourceId);
+ if (_volumeChanged)
+ {
+ AL.Source(track.SourceId, ALSourcef.Gain, _volume);
+
+ _volumeChanged = false;
+ }
+
+ AL.SourcePlay(track.SourceId);
}
}
- public void Stop(int Track)
+ /// <summary>
+ /// Stops playback
+ /// </summary>
+ /// <param name="trackId">The ID of the track to stop playback on</param>
+ public void Stop(int trackId)
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- lock (Td)
+ lock (track)
{
- Td.State = PlaybackState.Stopped;
+ track.State = PlaybackState.Stopped;
- AL.SourceStop(Td.SourceId);
+ AL.SourceStop(track.SourceId);
}
}
}
- public PlaybackState GetState(int Track)
+ /// <summary>
+ /// Get playback volume
+ /// </summary>
+ public float GetVolume() => _volume;
+
+ /// <summary>
+ /// Set playback volume
+ /// </summary>
+ /// <param name="volume">The volume of the playback</param>
+ public void SetVolume(float volume)
+ {
+ if (!_volumeChanged)
+ {
+ _volume = volume;
+ _volumeChanged = true;
+ }
+ }
+
+ /// <summary>
+ /// Gets the current playback state of the specified track
+ /// </summary>
+ /// <param name="trackId">The track to retrieve the playback state for</param>
+ public PlaybackState GetState(int trackId)
{
- if (Tracks.TryGetValue(Track, out Track Td))
+ if (_tracks.TryGetValue(trackId, out OpenALAudioTrack track))
{
- return Td.State;
+ return track.State;
}
return PlaybackState.Stopped;
@@ -358,11 +301,11 @@ namespace Ryujinx.Audio
Dispose(true);
}
- protected virtual void Dispose(bool Disposing)
+ protected virtual void Dispose(bool disposing)
{
- if (Disposing)
+ if (disposing)
{
- KeepPolling = false;
+ _keepPolling = false;
}
}
}
diff --git a/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioTrack.cs b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioTrack.cs
new file mode 100644
index 00000000..8629dc96
--- /dev/null
+++ b/Ryujinx.Audio/Renderers/OpenAL/OpenALAudioTrack.cs
@@ -0,0 +1,142 @@
+using OpenTK.Audio.OpenAL;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Ryujinx.Audio
+{
+ internal class OpenALAudioTrack : IDisposable
+ {
+ public int SourceId { get; private set; }
+ public int SampleRate { get; private set; }
+ public ALFormat Format { get; private set; }
+ public PlaybackState State { get; set; }
+
+ private ReleaseCallback _callback;
+
+ private ConcurrentDictionary<long, int> _buffers;
+
+ private Queue<long> _queuedTagsQueue;
+ private Queue<long> _releasedTagsQueue;
+
+ private bool _disposed;
+
+ public OpenALAudioTrack(int sampleRate, ALFormat format, ReleaseCallback callback)
+ {
+ SampleRate = sampleRate;
+ Format = format;
+ State = PlaybackState.Stopped;
+ SourceId = AL.GenSource();
+
+ _callback = callback;
+
+ _buffers = new ConcurrentDictionary<long, int>();
+
+ _queuedTagsQueue = new Queue<long>();
+ _releasedTagsQueue = new Queue<long>();
+ }
+
+ public bool ContainsBuffer(long tag)
+ {
+ foreach (long queuedTag in _queuedTagsQueue)
+ {
+ if (queuedTag == tag)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public long[] GetReleasedBuffers(int count)
+ {
+ AL.GetSource(SourceId, ALGetSourcei.BuffersProcessed, out int releasedCount);
+
+ releasedCount += _releasedTagsQueue.Count;
+
+ if (count > releasedCount)
+ {
+ count = releasedCount;
+ }
+
+ List<long> tags = new List<long>();
+
+ while (count-- > 0 && _releasedTagsQueue.TryDequeue(out long tag))
+ {
+ tags.Add(tag);
+ }
+
+ while (count-- > 0 && _queuedTagsQueue.TryDequeue(out long tag))
+ {
+ AL.SourceUnqueueBuffers(SourceId, 1);
+
+ tags.Add(tag);
+ }
+
+ return tags.ToArray();
+ }
+
+ public int AppendBuffer(long tag)
+ {
+ if (_disposed)
+ {
+ throw new ObjectDisposedException(GetType().Name);
+ }
+
+ int id = AL.GenBuffer();
+
+ _buffers.AddOrUpdate(tag, id, (key, oldId) =>
+ {
+ AL.DeleteBuffer(oldId);
+
+ return id;
+ });
+
+ _queuedTagsQueue.Enqueue(tag);
+
+ return id;
+ }
+
+ public void CallReleaseCallbackIfNeeded()
+ {
+ AL.GetSource(SourceId, ALGetSourcei.BuffersProcessed, out int releasedCount);
+
+ if (releasedCount > 0)
+ {
+ // If we signal, then we also need to have released buffers available
+ // to return when GetReleasedBuffers is called.
+ // If playback needs to be re-started due to all buffers being processed,
+ // then OpenAL zeros the counts (ReleasedCount), so we keep it on the queue.
+ while (releasedCount-- > 0 && _queuedTagsQueue.TryDequeue(out long tag))
+ {
+ AL.SourceUnqueueBuffers(SourceId, 1);
+
+ _releasedTagsQueue.Enqueue(tag);
+ }
+
+ _callback();
+ }
+ }
+
+ public void Dispose()
+ {
+ Dispose(true);
+ }
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (disposing && !_disposed)
+ {
+ _disposed = true;
+
+ AL.DeleteSource(SourceId);
+
+ foreach (int id in _buffers.Values)
+ {
+ AL.DeleteBuffer(id);
+ }
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
index f5e4c57d..1e487a6d 100644
--- a/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
+++ b/Ryujinx.Audio/Renderers/SoundIo/SoundIoAudioOut.cs
@@ -1,5 +1,6 @@
using Ryujinx.Audio.SoundIo;
using SoundIOSharp;
+using System;
using System.Collections.Generic;
namespace Ryujinx.Audio
@@ -15,22 +16,32 @@ namespace Ryujinx.Audio
private const int MaximumTracks = 256;
/// <summary>
+ /// The volume of audio renderer
+ /// </summary>
+ private float _volume = 1.0f;
+
+ /// <summary>
+ /// True if the volume of audio renderer have changed
+ /// </summary>
+ private bool _volumeChanged;
+
+ /// <summary>
/// The <see cref="SoundIO"/> audio context
/// </summary>
- private SoundIO m_AudioContext;
+ private SoundIO _audioContext;
/// <summary>
/// The <see cref="SoundIODevice"/> audio device
/// </summary>
- private SoundIODevice m_AudioDevice;
+ private SoundIODevice _audioDevice;
/// <summary>
/// An object pool containing <see cref="SoundIoAudioTrack"/> objects
/// </summary>
- private SoundIoAudioTrackPool m_TrackPool;
+ private SoundIoAudioTrackPool _trackPool;
/// <summary>
- /// True if SoundIO is supported on the device.
+ /// True if SoundIO is supported on the device
/// </summary>
public static bool IsSupported
{
@@ -45,27 +56,13 @@ namespace Ryujinx.Audio
/// </summary>
public SoundIoAudioOut()
{
- m_AudioContext = new SoundIO();
+ _audioContext = new SoundIO();
- m_AudioContext.Connect();
- m_AudioContext.FlushEvents();
+ _audioContext.Connect();
+ _audioContext.FlushEvents();
- m_AudioDevice = FindNonRawDefaultAudioDevice(m_AudioContext, true);
- m_TrackPool = new SoundIoAudioTrackPool(m_AudioContext, m_AudioDevice, MaximumTracks);
- }
-
- /// <summary>
- /// Gets the current playback state of the specified track
- /// </summary>
- /// <param name="trackId">The track to retrieve the playback state for</param>
- public PlaybackState GetState(int trackId)
- {
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
- {
- return track.State;
- }
-
- return PlaybackState.Stopped;
+ _audioDevice = FindNonRawDefaultAudioDevice(_audioContext, true);
+ _trackPool = new SoundIoAudioTrackPool(_audioContext, _audioDevice, MaximumTracks);
}
/// <summary>
@@ -77,7 +74,7 @@ namespace Ryujinx.Audio
/// <returns>The created track's Track ID</returns>
public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
{
- if (!m_TrackPool.TryGet(out SoundIoAudioTrack track))
+ if (!_trackPool.TryGet(out SoundIoAudioTrack track))
{
return -1;
}
@@ -94,38 +91,52 @@ namespace Ryujinx.Audio
/// <param name="trackId">The ID of the track to close</param>
public void CloseTrack(int trackId)
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
// Close and dispose of the track
track.Close();
// Recycle the track back into the pool
- m_TrackPool.Put(track);
+ _trackPool.Put(track);
}
}
/// <summary>
- /// Starts playback
+ /// Returns a value indicating whether the specified buffer is currently reserved by the specified track
/// </summary>
- /// <param name="trackId">The ID of the track to start playback on</param>
- public void Start(int trackId)
+ /// <param name="trackId">The track to check</param>
+ /// <param name="bufferTag">The buffer tag to check</param>
+ public bool ContainsBuffer(int trackId, long bufferTag)
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
- track.Start();
+ return track.ContainsBuffer(bufferTag);
}
+
+ return false;
}
/// <summary>
- /// Stops playback
+ /// Gets a list of buffer tags the specified track is no longer reserving
/// </summary>
- /// <param name="trackId">The ID of the track to stop playback on</param>
- public void Stop(int trackId)
+ /// <param name="trackId">The track to retrieve buffer tags from</param>
+ /// <param name="maxCount">The maximum amount of buffer tags to retrieve</param>
+ /// <returns>Buffers released by the specified track</returns>
+ public long[] GetReleasedBuffers(int trackId, int maxCount)
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
- track.Stop();
+ List<long> bufferTags = new List<long>();
+
+ while(maxCount-- > 0 && track.ReleasedBuffers.TryDequeue(out long tag))
+ {
+ bufferTags.Add(tag);
+ }
+
+ return bufferTags.ToArray();
}
+
+ return new long[0];
}
/// <summary>
@@ -135,51 +146,75 @@ namespace Ryujinx.Audio
/// <param name="trackId">The track to append the buffer to</param>
/// <param name="bufferTag">The internal tag of the buffer</param>
/// <param name="buffer">The buffer to append to the track</param>
- public void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer)
- where T : struct
+ public void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
+ if (_volumeChanged)
+ {
+ track.AudioStream.SetVolume(_volume);
+
+ _volumeChanged = false;
+ }
+
track.AppendBuffer(bufferTag, buffer);
}
}
/// <summary>
- /// Returns a value indicating whether the specified buffer is currently reserved by the specified track
+ /// Starts playback
/// </summary>
- /// <param name="trackId">The track to check</param>
- /// <param name="bufferTag">The buffer tag to check</param>
- public bool ContainsBuffer(int trackId, long bufferTag)
+ /// <param name="trackId">The ID of the track to start playback on</param>
+ public void Start(int trackId)
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
- return track.ContainsBuffer(bufferTag);
+ track.Start();
}
-
- return false;
}
/// <summary>
- /// Gets a list of buffer tags the specified track is no longer reserving
+ /// Stops playback
/// </summary>
- /// <param name="trackId">The track to retrieve buffer tags from</param>
- /// <param name="maxCount">The maximum amount of buffer tags to retrieve</param>
- /// <returns>Buffers released by the specified track</returns>
- public long[] GetReleasedBuffers(int trackId, int maxCount)
+ /// <param name="trackId">The ID of the track to stop playback on</param>
+ public void Stop(int trackId)
{
- if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
- List<long> bufferTags = new List<long>();
+ track.Stop();
+ }
+ }
- while(maxCount-- > 0 && track.ReleasedBuffers.TryDequeue(out long tag))
- {
- bufferTags.Add(tag);
- }
+ /// <summary>
+ /// Get playback volume
+ /// </summary>
+ public float GetVolume() => _volume;
- return bufferTags.ToArray();
+ /// <summary>
+ /// Set playback volume
+ /// </summary>
+ /// <param name="volume">The volume of the playback</param>
+ public void SetVolume(float volume)
+ {
+ if (!_volumeChanged)
+ {
+ _volume = volume;
+ _volumeChanged = true;
+ }
+ }
+
+ /// <summary>
+ /// Gets the current playback state of the specified track
+ /// </summary>
+ /// <param name="trackId">The track to retrieve the playback state for</param>
+ public PlaybackState GetState(int trackId)
+ {
+ if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
+ {
+ return track.State;
}
- return new long[0];
+ return PlaybackState.Stopped;
}
/// <summary>
@@ -187,9 +222,9 @@ namespace Ryujinx.Audio
/// </summary>
public void Dispose()
{
- m_TrackPool.Dispose();
- m_AudioContext.Disconnect();
- m_AudioContext.Dispose();
+ _trackPool.Dispose();
+ _audioContext.Disconnect();
+ _audioContext.Dispose();
}
/// <summary>
diff --git a/Ryujinx.HLE/HOS/Services/Audio/AudioOutManager/IAudioOut.cs b/Ryujinx.HLE/HOS/Services/Audio/AudioOutManager/IAudioOut.cs
index 5b6983d6..11d8036c 100644
--- a/Ryujinx.HLE/HOS/Services/Audio/AudioOutManager/IAudioOut.cs
+++ b/Ryujinx.HLE/HOS/Services/Audio/AudioOutManager/IAudioOut.cs
@@ -147,6 +147,32 @@ namespace Ryujinx.HLE.HOS.Services.Audio.AudioOutManager
return ResultCode.Success;
}
+ [Command(12)] // 6.0.0+
+ // SetAudioOutVolume(s32)
+ public ResultCode SetAudioOutVolume(ServiceCtx context)
+ {
+ // Games send a gain value here, so we need to apply it on the current volume value.
+
+ float gain = context.RequestData.ReadSingle();
+ float currentVolume = _audioOut.GetVolume();
+ float newVolume = Math.Clamp(currentVolume + gain, 0.0f, 1.0f);
+
+ _audioOut.SetVolume(newVolume);
+
+ return ResultCode.Success;
+ }
+
+ [Command(13)] // 6.0.0+
+ // GetAudioOutVolume() -> s32
+ public ResultCode GetAudioOutVolume(ServiceCtx context)
+ {
+ float volume = _audioOut.GetVolume();
+
+ context.ResponseData.Write(volume);
+
+ return ResultCode.Success;
+ }
+
public void Dispose()
{
Dispose(true);
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-09 05:23:32 +0000