0
0
Fork 0
mirror of https://github.com/GreemDev/Ryujinx.git synced 2024-12-22 23:55:47 +00:00

audout:u: Implement SetAudioOutVolume and GetAudioOutVolume (#781)

* audout:u: Implement SetAudioOutVolume and GetAudioOutVolume

- Implementation of `audout:u` SetAudioOutVolume and GetAudioOutVolume (checked with RE).
- Add Get and Set for Volume into audio backends.
- Cleanup of all audio backends to follow the `IAalOutput` structure and .NET standard.
- Split OpenAL backend into 2 files for consistency.

* Address comments

* Fix the volume calculation
This commit is contained in:
Ac_K 2019-10-11 17:54:29 +02:00 committed by Thomas Guillemard
parent 4210fe2b7b
commit c17e1f99f0
6 changed files with 482 additions and 325 deletions

View file

@ -15,8 +15,13 @@ namespace Ryujinx.Audio
void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct; void AppendBuffer<T>(int trackId, long bufferTag, T[] buffer) where T : struct;
void Start(int trackId); void Start(int trackId);
void Stop(int trackId); void Stop(int trackId);
float GetVolume();
void SetVolume(float volume);
PlaybackState GetState(int trackId); PlaybackState GetState(int trackId);
} }
} }

View file

@ -1,4 +1,5 @@
using System.Collections.Concurrent; using System;
using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
namespace Ryujinx.Audio namespace Ryujinx.Audio
@ -8,17 +9,18 @@ namespace Ryujinx.Audio
/// </summary> /// </summary>
public class DummyAudioOut : IAalOutput public class DummyAudioOut : IAalOutput
{ {
private int lastTrackId = 1; private int _lastTrackId = 1;
private float _volume = 1.0f;
private ConcurrentQueue<int> m_TrackIds; private ConcurrentQueue<int> _trackIds;
private ConcurrentQueue<long> m_Buffers; private ConcurrentQueue<long> _buffers;
private ConcurrentDictionary<int, ReleaseCallback> m_ReleaseCallbacks; private ConcurrentDictionary<int, ReleaseCallback> _releaseCallbacks;
public DummyAudioOut() public DummyAudioOut()
{ {
m_Buffers = new ConcurrentQueue<long>(); _buffers = new ConcurrentQueue<long>();
m_TrackIds = new ConcurrentQueue<int>(); _trackIds = new ConcurrentQueue<int>();
m_ReleaseCallbacks = new ConcurrentDictionary<int, ReleaseCallback>(); _releaseCallbacks = new ConcurrentDictionary<int, ReleaseCallback>();
} }
/// <summary> /// <summary>
@ -30,38 +32,23 @@ namespace Ryujinx.Audio
public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback) public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
{ {
int trackId; if (!_trackIds.TryDequeue(out int trackId))
if (!m_TrackIds.TryDequeue(out trackId))
{ {
trackId = ++lastTrackId; trackId = ++_lastTrackId;
} }
m_ReleaseCallbacks[trackId] = callback; _releaseCallbacks[trackId] = callback;
return trackId; return trackId;
} }
public void CloseTrack(int trackId) public void CloseTrack(int trackId)
{ {
m_TrackIds.Enqueue(trackId); _trackIds.Enqueue(trackId);
m_ReleaseCallbacks.Remove(trackId, out _); _releaseCallbacks.Remove(trackId, out _);
} }
public void Start(int trackId) { } public bool ContainsBuffer(int trackID, long bufferTag) => false;
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 long[] GetReleasedBuffers(int trackId, int maxCount) public long[] GetReleasedBuffers(int trackId, int maxCount)
{ {
@ -69,7 +56,7 @@ namespace Ryujinx.Audio
for (int i = 0; i < maxCount; i++) for (int i = 0; i < maxCount; i++)
{ {
if (!m_Buffers.TryDequeue(out long tag)) if (!_buffers.TryDequeue(out long tag))
{ {
break; break;
} }
@ -80,11 +67,30 @@ namespace Ryujinx.Audio
return bufferTags.ToArray(); 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() public void Dispose()
{ {
m_Buffers.Clear(); _buffers.Clear();
} }
} }
} }

View file

@ -2,7 +2,6 @@ using OpenTK.Audio;
using OpenTK.Audio.OpenAL; using OpenTK.Audio.OpenAL;
using System; using System;
using System.Collections.Concurrent; using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Threading; using System.Threading;
@ -13,174 +12,43 @@ namespace Ryujinx.Audio
/// </summary> /// </summary>
public class OpenALAudioOut : IAalOutput, IDisposable public class OpenALAudioOut : IAalOutput, IDisposable
{ {
/// <summary>
/// The maximum amount of tracks we can issue simultaneously
/// </summary>
private const int MaxTracks = 256; private const int MaxTracks = 256;
private const int MaxReleased = 32; /// <summary>
/// The <see cref="OpenTK.Audio"/> audio context
private AudioContext Context; /// </summary>
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;
public OpenALAudioOut()
{
Context = new AudioContext();
Tracks = new ConcurrentDictionary<int, Track>();
KeepPolling = true;
AudioPollerThread = new Thread(AudioPollerWork);
AudioPollerThread.Start();
}
/// <summary> /// <summary>
/// True if OpenAL is supported on the device. /// An object pool containing <see cref="OpenALAudioTrack"/> objects
/// </summary>
private ConcurrentDictionary<int, OpenALAudioTrack> _tracks;
/// <summary>
/// True if the thread need to keep polling
/// </summary>
private bool _keepPolling;
/// <summary>
/// The poller thread audio context
/// </summary>
private Thread _audioPollerThread;
/// <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>
/// True if OpenAL is supported on the device
/// </summary> /// </summary>
public static bool IsSupported 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() private void AudioPollerWork()
{ {
do 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. // If it's not slept it will waste cycles.
Thread.Sleep(10); 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; return -1;
} }
private ALFormat GetALFormat(int Channels) private ALFormat GetALFormat(int channels)
{ {
switch (Channels) switch (channels)
{ {
case 1: return ALFormat.Mono16; case 1: return ALFormat.Mono16;
case 2: return ALFormat.Stereo16; case 2: return ALFormat.Stereo16;
case 6: return ALFormat.Multi51Chn16Ext; 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; 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; 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 (Tracks.TryGetValue(Track, out Track Td)) if (!_volumeChanged)
{ {
return Td.State; _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(trackId, out OpenALAudioTrack track))
{
return track.State;
} }
return PlaybackState.Stopped; return PlaybackState.Stopped;
@ -358,11 +301,11 @@ namespace Ryujinx.Audio
Dispose(true); Dispose(true);
} }
protected virtual void Dispose(bool Disposing) protected virtual void Dispose(bool disposing)
{ {
if (Disposing) if (disposing)
{ {
KeepPolling = false; _keepPolling = false;
} }
} }
} }

View file

@ -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);
}
}
}
}
}

View file

@ -1,5 +1,6 @@
using Ryujinx.Audio.SoundIo; using Ryujinx.Audio.SoundIo;
using SoundIOSharp; using SoundIOSharp;
using System;
using System.Collections.Generic; using System.Collections.Generic;
namespace Ryujinx.Audio namespace Ryujinx.Audio
@ -14,23 +15,33 @@ namespace Ryujinx.Audio
/// </summary> /// </summary>
private const int MaximumTracks = 256; 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> /// <summary>
/// The <see cref="SoundIO"/> audio context /// The <see cref="SoundIO"/> audio context
/// </summary> /// </summary>
private SoundIO m_AudioContext; private SoundIO _audioContext;
/// <summary> /// <summary>
/// The <see cref="SoundIODevice"/> audio device /// The <see cref="SoundIODevice"/> audio device
/// </summary> /// </summary>
private SoundIODevice m_AudioDevice; private SoundIODevice _audioDevice;
/// <summary> /// <summary>
/// An object pool containing <see cref="SoundIoAudioTrack"/> objects /// An object pool containing <see cref="SoundIoAudioTrack"/> objects
/// </summary> /// </summary>
private SoundIoAudioTrackPool m_TrackPool; private SoundIoAudioTrackPool _trackPool;
/// <summary> /// <summary>
/// True if SoundIO is supported on the device. /// True if SoundIO is supported on the device
/// </summary> /// </summary>
public static bool IsSupported public static bool IsSupported
{ {
@ -45,27 +56,13 @@ namespace Ryujinx.Audio
/// </summary> /// </summary>
public SoundIoAudioOut() public SoundIoAudioOut()
{ {
m_AudioContext = new SoundIO(); _audioContext = new SoundIO();
m_AudioContext.Connect(); _audioContext.Connect();
m_AudioContext.FlushEvents(); _audioContext.FlushEvents();
m_AudioDevice = FindNonRawDefaultAudioDevice(m_AudioContext, true); _audioDevice = FindNonRawDefaultAudioDevice(_audioContext, true);
m_TrackPool = new SoundIoAudioTrackPool(m_AudioContext, m_AudioDevice, MaximumTracks); _trackPool = new SoundIoAudioTrackPool(_audioContext, _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;
} }
/// <summary> /// <summary>
@ -77,7 +74,7 @@ namespace Ryujinx.Audio
/// <returns>The created track's Track ID</returns> /// <returns>The created track's Track ID</returns>
public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback) public int OpenTrack(int sampleRate, int channels, ReleaseCallback callback)
{ {
if (!m_TrackPool.TryGet(out SoundIoAudioTrack track)) if (!_trackPool.TryGet(out SoundIoAudioTrack track))
{ {
return -1; return -1;
} }
@ -94,53 +91,13 @@ namespace Ryujinx.Audio
/// <param name="trackId">The ID of the track to close</param> /// <param name="trackId">The ID of the track to close</param>
public void CloseTrack(int trackId) 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 // Close and dispose of the track
track.Close(); track.Close();
// Recycle the track back into the pool // Recycle the track back into the pool
m_TrackPool.Put(track); _trackPool.Put(track);
}
}
/// <summary>
/// Starts playback
/// </summary>
/// <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))
{
track.Start();
}
}
/// <summary>
/// Stops playback
/// </summary>
/// <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))
{
track.Stop();
}
}
/// <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 (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
track.AppendBuffer(bufferTag, buffer);
} }
} }
@ -151,7 +108,7 @@ namespace Ryujinx.Audio
/// <param name="bufferTag">The buffer tag to check</param> /// <param name="bufferTag">The buffer tag to check</param>
public bool ContainsBuffer(int trackId, long bufferTag) public bool ContainsBuffer(int trackId, long bufferTag)
{ {
if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{ {
return track.ContainsBuffer(bufferTag); return track.ContainsBuffer(bufferTag);
} }
@ -167,7 +124,7 @@ namespace Ryujinx.Audio
/// <returns>Buffers released by the specified track</returns> /// <returns>Buffers released by the specified track</returns>
public long[] GetReleasedBuffers(int trackId, int maxCount) public long[] GetReleasedBuffers(int trackId, int maxCount)
{ {
if (m_TrackPool.TryGet(trackId, out SoundIoAudioTrack track)) if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{ {
List<long> bufferTags = new List<long>(); List<long> bufferTags = new List<long>();
@ -182,14 +139,92 @@ namespace Ryujinx.Audio
return new long[0]; return new long[0];
} }
/// <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 (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
if (_volumeChanged)
{
track.AudioStream.SetVolume(_volume);
_volumeChanged = false;
}
track.AppendBuffer(bufferTag, buffer);
}
}
/// <summary>
/// Starts playback
/// </summary>
/// <param name="trackId">The ID of the track to start playback on</param>
public void Start(int trackId)
{
if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
track.Start();
}
}
/// <summary>
/// Stops playback
/// </summary>
/// <param name="trackId">The ID of the track to stop playback on</param>
public void Stop(int trackId)
{
if (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
track.Stop();
}
}
/// <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 (_trackPool.TryGet(trackId, out SoundIoAudioTrack track))
{
return track.State;
}
return PlaybackState.Stopped;
}
/// <summary> /// <summary>
/// Releases the unmanaged resources used by the <see cref="SoundIoAudioOut" /> /// Releases the unmanaged resources used by the <see cref="SoundIoAudioOut" />
/// </summary> /// </summary>
public void Dispose() public void Dispose()
{ {
m_TrackPool.Dispose(); _trackPool.Dispose();
m_AudioContext.Disconnect(); _audioContext.Disconnect();
m_AudioContext.Dispose(); _audioContext.Dispose();
} }
/// <summary> /// <summary>

View file

@ -147,6 +147,32 @@ namespace Ryujinx.HLE.HOS.Services.Audio.AudioOutManager
return ResultCode.Success; 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() public void Dispose()
{ {
Dispose(true); Dispose(true);