mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-12-13 09:42:02 +00:00
5b26e4ef94
Changes: Implement software surround downmixing (fix #796). Fix a crash when no audio renderer were created when stopping emulation. NOTE: This PR also disable support of 5.1 surround on the OpenAL backend as we cannot detect if the hardware directly support it. (the downmixing applied by OpenAL on Windows is terribly slow)
353 lines
No EOL
11 KiB
C#
353 lines
No EOL
11 KiB
C#
using OpenTK.Audio;
|
|
using OpenTK.Audio.OpenAL;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
|
|
namespace Ryujinx.Audio
|
|
{
|
|
/// <summary>
|
|
/// An audio renderer that uses OpenAL as the audio backend
|
|
/// </summary>
|
|
public class OpenALAudioOut : IAalOutput, IDisposable
|
|
{
|
|
/// <summary>
|
|
/// The maximum amount of tracks we can issue simultaneously
|
|
/// </summary>
|
|
private const int MaxTracks = 256;
|
|
|
|
/// <summary>
|
|
/// The <see cref="OpenTK.Audio"/> audio context
|
|
/// </summary>
|
|
private AudioContext _context;
|
|
|
|
/// <summary>
|
|
/// 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>
|
|
public static bool IsSupported
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return AudioContext.AvailableDevices.Count > 0;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public OpenALAudioOut()
|
|
{
|
|
_context = new AudioContext();
|
|
_tracks = new ConcurrentDictionary<int, OpenALAudioTrack>();
|
|
_keepPolling = true;
|
|
_audioPollerThread = new Thread(AudioPollerWork)
|
|
{
|
|
Name = "Audio.PollerThread"
|
|
};
|
|
|
|
_audioPollerThread.Start();
|
|
}
|
|
|
|
private void AudioPollerWork()
|
|
{
|
|
do
|
|
{
|
|
foreach (OpenALAudioTrack track in _tracks.Values)
|
|
{
|
|
lock (track)
|
|
{
|
|
track.CallReleaseCallbackIfNeeded();
|
|
}
|
|
}
|
|
|
|
// If it's not slept it will waste cycles.
|
|
Thread.Sleep(10);
|
|
}
|
|
while (_keepPolling);
|
|
|
|
foreach (OpenALAudioTrack track in _tracks.Values)
|
|
{
|
|
track.Dispose();
|
|
}
|
|
|
|
_tracks.Clear();
|
|
_context.Dispose();
|
|
}
|
|
|
|
public bool SupportsChannelCount(int channels)
|
|
{
|
|
// NOTE: OpenAL doesn't give us a way to know if the 5.1 setup is supported by hardware or actually emulated.
|
|
// TODO: find a way to determine hardware support.
|
|
return channels == 1 || channels == 2;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new audio track with the specified parameters
|
|
/// </summary>
|
|
/// <param name="sampleRate">The requested sample rate</param>
|
|
/// <param name="hardwareChannels">The requested hardware channels</param>
|
|
/// <param name="virtualChannels">The requested virtual 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>
|
|
/// <returns>The created track's Track ID</returns>
|
|
public int OpenHardwareTrack(int sampleRate, int hardwareChannels, int virtualChannels, ReleaseCallback callback)
|
|
{
|
|
OpenALAudioTrack track = new OpenALAudioTrack(sampleRate, GetALFormat(hardwareChannels), hardwareChannels, virtualChannels, callback);
|
|
|
|
for (int id = 0; id < MaxTracks; id++)
|
|
{
|
|
if (_tracks.TryAdd(id, track))
|
|
{
|
|
return id;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private ALFormat GetALFormat(int channels)
|
|
{
|
|
switch (channels)
|
|
{
|
|
case 1: return ALFormat.Mono16;
|
|
case 2: return ALFormat.Stereo16;
|
|
case 6: return ALFormat.Multi51Chn16Ext;
|
|
}
|
|
|
|
throw new ArgumentOutOfRangeException(nameof(channels));
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
track.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
return track.ContainsBuffer(bufferTag);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
return track.GetReleasedBuffers(maxCount);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
int bufferId = track.AppendBuffer(bufferTag);
|
|
|
|
// Do we need to downmix?
|
|
if (track.HardwareChannels != track.VirtualChannels)
|
|
{
|
|
short[] downmixedBuffer;
|
|
|
|
ReadOnlySpan<short> bufferPCM16 = MemoryMarshal.Cast<T, short>(buffer);
|
|
|
|
if (track.VirtualChannels == 6)
|
|
{
|
|
downmixedBuffer = Downmixing.DownMixSurroundToStereo(bufferPCM16);
|
|
|
|
if (track.HardwareChannels == 1)
|
|
{
|
|
downmixedBuffer = Downmixing.DownMixStereoToMono(downmixedBuffer);
|
|
}
|
|
}
|
|
else if (track.VirtualChannels == 2)
|
|
{
|
|
downmixedBuffer = Downmixing.DownMixStereoToMono(bufferPCM16);
|
|
}
|
|
else
|
|
{
|
|
throw new NotImplementedException($"Downmixing from {track.VirtualChannels} to {track.HardwareChannels} not implemented!");
|
|
}
|
|
|
|
AL.BufferData(bufferId, track.Format, downmixedBuffer, downmixedBuffer.Length * sizeof(ushort), track.SampleRate);
|
|
}
|
|
else
|
|
{
|
|
AL.BufferData(bufferId, track.Format, buffer, buffer.Length * sizeof(ushort), track.SampleRate);
|
|
}
|
|
|
|
AL.SourceQueueBuffer(track.SourceId, bufferId);
|
|
|
|
StartPlaybackIfNeeded(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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
track.State = PlaybackState.Playing;
|
|
|
|
StartPlaybackIfNeeded(track);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void StartPlaybackIfNeeded(OpenALAudioTrack track)
|
|
{
|
|
AL.GetSource(track.SourceId, ALGetSourcei.SourceState, out int stateInt);
|
|
|
|
ALSourceState State = (ALSourceState)stateInt;
|
|
|
|
if (State != ALSourceState.Playing && track.State == PlaybackState.Playing)
|
|
{
|
|
if (_volumeChanged)
|
|
{
|
|
AL.Source(track.SourceId, ALSourcef.Gain, _volume);
|
|
|
|
_volumeChanged = false;
|
|
}
|
|
|
|
AL.SourcePlay(track.SourceId);
|
|
}
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
lock (track)
|
|
{
|
|
track.State = PlaybackState.Stopped;
|
|
|
|
AL.SourceStop(track.SourceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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(trackId, out OpenALAudioTrack track))
|
|
{
|
|
return track.State;
|
|
}
|
|
|
|
return PlaybackState.Stopped;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
_keepPolling = false;
|
|
}
|
|
}
|
|
}
|
|
} |