Merge pull request #6660 from smoogipoo/fix-wasapi-init

Fix WASAPI initialisation and BASS logging

Author: peppy

osu.Framework.Tests/Audio/AudioManagerWithDeviceLoss.cs

@@ -17,7 +17,7 @@ namespace osu.Framework.Tests.Audio
     internal class AudioManagerWithDeviceLoss : AudioManager
     {
         public AudioManagerWithDeviceLoss(AudioThread audioThread, ResourceStore<byte[]> trackStore, ResourceStore<byte[]> sampleStore)
-            : base(audioThread, trackStore, sampleStore)
+            : base(audioThread, trackStore, sampleStore, null)
         {
         }
 

osu.Framework/Audio/AudioManager.cs

@@ -9,6 +9,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
+using JetBrains.Annotations;
 using ManagedBass;
 using ManagedBass.Fx;
 using ManagedBass.Mix;
@@ -17,6 +18,7 @@
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
+using osu.Framework.Configuration;
 using osu.Framework.Development;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.IO.Stores;
@@ -176,19 +178,27 @@ public class AudioManager : AudioCollectionManager<AudioComponent>
         /// <param name="audioThread">The host's audio thread.</param>
         /// <param name="trackStore">The resource store containing all audio tracks to be used in the future.</param>
         /// <param name="sampleStore">The sample store containing all audio samples to be used in the future.</param>
-        public AudioManager(AudioThread audioThread, ResourceStore<byte[]> trackStore, ResourceStore<byte[]> sampleStore)
+        /// <param name="config"></param>
+        public AudioManager(AudioThread audioThread, ResourceStore<byte[]> trackStore, ResourceStore<byte[]> sampleStore, [CanBeNull] FrameworkConfigManager config)
         {
             thread = audioThread;
 
             thread.RegisterManager(this);
 
-            AudioDevice.ValueChanged += _ => onDeviceChanged();
-            UseExperimentalWasapi.ValueChanged += _ => onDeviceChanged();
-            GlobalMixerHandle.ValueChanged += handle =>
+            if (config != null)
             {
-                onDeviceChanged();
-                usingGlobalMixer.Value = handle.NewValue.HasValue;
-            };
+                // attach config bindables
+                config.BindWith(FrameworkSetting.AudioDevice, AudioDevice);
+                config.BindWith(FrameworkSetting.AudioUseExperimentalWasapi, UseExperimentalWasapi);
+                config.BindWith(FrameworkSetting.VolumeUniversal, Volume);
+                config.BindWith(FrameworkSetting.VolumeEffect, VolumeSample);
+                config.BindWith(FrameworkSetting.VolumeMusic, VolumeTrack);
+            }
+
+            AudioDevice.ValueChanged += _ => scheduler.AddOnce(initCurrentDevice);
+            UseExperimentalWasapi.ValueChanged += _ => scheduler.AddOnce(initCurrentDevice);
+            // initCurrentDevice not required for changes to `GlobalMixerHandle` as it is only changed when experimental wasapi is toggled (handled above).
+            GlobalMixerHandle.ValueChanged += handle => usingGlobalMixer.Value = handle.NewValue.HasValue;
 
             AddItem(TrackMixer = createAudioMixer(null, nameof(TrackMixer)));
             AddItem(SampleMixer = createAudioMixer(null, nameof(SampleMixer)));
@@ -209,12 +219,12 @@ public AudioManager(AudioThread audioThread, ResourceStore<byte[]> trackStore, R
                 return store;
             });
 
-            CancellationToken token = cancelSource.Token;
-
             syncAudioDevices();
+
+            // check for changes in any audio devices every 1000ms (slightly expensive operation)
+            CancellationToken token = cancelSource.Token;
             scheduler.AddDelayed(() =>
             {
-                // sync audioDevices every 1000ms
                 new Thread(() =>
                 {
                     while (!token.IsCancellationRequested)
@@ -248,23 +258,6 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
         }
 
-        private void onDeviceChanged()
-        {
-            scheduler.Add(() => setAudioDevice(AudioDevice.Value));
-        }
-
-        private void onDevicesChanged()
-        {
-            scheduler.Add(() =>
-            {
-                if (cancelSource.IsCancellationRequested)
-                    return;
-
-                if (!IsCurrentDeviceValid())
-                    setAudioDevice();
-            });
-        }
-
         private static int userMixerID;
 
         /// <summary>
@@ -334,81 +327,58 @@ public ISampleStore GetSampleStore(IResourceStore<byte[]> store = null, AudioMix
         }
 
         /// <summary>
-        /// Sets the output audio device by its name.
+        /// (Re-)Initialises BASS for the current <see cref="AudioDevice"/>.
         /// This will automatically fall back to the system default device on failure.
         /// </summary>
-        /// <param name="deviceName">Name of the audio device, or null to use the configured device preference <see cref="AudioDevice"/>.</param>
-        private bool setAudioDevice(string deviceName = null)
+        private void initCurrentDevice()
         {
-            deviceName ??= AudioDevice.Value;
+            string deviceName = AudioDevice.Value;
 
             // try using the specified device
             int deviceIndex = audioDeviceNames.FindIndex(d => d == deviceName);
-            if (deviceIndex >= 0 && setAudioDevice(BASS_INTERNAL_DEVICE_COUNT + deviceIndex))
-                return true;
+            if (deviceIndex >= 0 && trySetDevice(BASS_INTERNAL_DEVICE_COUNT + deviceIndex)) return;
 
             // try using the system default if there is any device present.
             // mobiles are an exception as the built-in speakers may not be provided as an audio device name,
             // but they are still provided by BASS under the internal device name "Default".
-            if ((audioDeviceNames.Count > 0 || RuntimeInfo.IsMobile) && setAudioDevice(bass_default_device))
-                return true;
+            if ((audioDeviceNames.Count > 0 || RuntimeInfo.IsMobile) && trySetDevice(bass_default_device)) return;
 
             // no audio devices can be used, so try using Bass-provided "No sound" device as last resort.
-            if (setAudioDevice(Bass.NoSoundDevice))
-                return true;
+            trySetDevice(Bass.NoSoundDevice);
 
             // we're boned. even "No sound" device won't initialise.
-            return false;
-        }
+            return;
 
-        private bool setAudioDevice(int deviceIndex)
-        {
-            var device = audioDevices.ElementAtOrDefault(deviceIndex);
+            bool trySetDevice(int deviceId)
+            {
+                var device = audioDevices.ElementAtOrDefault(deviceId);
 
-            // device is invalid
-            if (!device.IsEnabled)
-                return false;
+                // device is invalid
+                if (!device.IsEnabled)
+                    return false;
 
-            // we don't want bass initializing with real audio device on headless test runs.
-            if (deviceIndex != Bass.NoSoundDevice && DebugUtils.IsNUnitRunning)
-                return false;
+                // we don't want bass initializing with real audio device on headless test runs.
+                if (deviceId != Bass.NoSoundDevice && DebugUtils.IsNUnitRunning)
+                    return false;
 
-            // initialize new device
-            bool initSuccess = InitBass(deviceIndex);
-            if (Bass.LastError != Errors.Already && BassUtils.CheckFaulted(false))
-                return false;
+                // initialize new device
+                if (!InitBass(deviceId))
+                    return false;
 
-            if (!initSuccess)
-            {
-                Logger.Log("BASS failed to initialize but did not provide an error code", level: LogLevel.Error);
-                return false;
-            }
+                //we have successfully initialised a new device.
+                UpdateDevice(deviceId);
 
-            Logger.Log($@"🔈 BASS initialised
-                          BASS version:           {Bass.Version}
-                          BASS FX version:        {BassFx.Version}
-                          BASS MIX version:       {BassMix.Version}
-                          Device:                 {device.Name}
-                          Driver:                 {device.Driver}
-                          Update period:          {Bass.UpdatePeriod} ms
-                          Device buffer length:   {Bass.DeviceBufferLength} ms
-                          Playback buffer length: {Bass.PlaybackBufferLength} ms");
-
-            //we have successfully initialised a new device.
-            UpdateDevice(deviceIndex);
-
-            return true;
+                return true;
+            }
         }
 
         /// <summary>
         /// This method calls <see cref="Bass.Init(int, int, DeviceInitFlags, IntPtr, IntPtr)"/>.
         /// It can be overridden for unit testing.
         /// </summary>
+        /// <param name="device">The device to initialise.</param>
         protected virtual bool InitBass(int device)
         {
-            if (Bass.CurrentDevice == device)
-                return true;
-
             // this likely doesn't help us but also doesn't seem to cause any issues or any cpu increase.
             Bass.UpdatePeriod = 5;
 
@@ -438,16 +408,47 @@ protected virtual bool InitBass(int device)
             // See https://www.un4seen.com/forum/?topic=19601 for more information.
             Bass.Configure((ManagedBass.Configuration)70, false);
 
-            if (UseExperimentalWasapi.Value)
+            bool success = attemptInit();
+
+            if (success || !UseExperimentalWasapi.Value)
+                return success;
+
+            // in the case we're using experimental WASAPI, give a second chance of initialisation by forcefully disabling it.
+            Logger.Log($"BASS device {device} failed to initialise with experimental WASAPI, disabling", level: LogLevel.Error);
+            UseExperimentalWasapi.Value = false;
+            return attemptInit();
+
+            bool attemptInit()
             {
-                if (thread.InitDevice(device, true))
+                bool innerSuccess = thread.InitDevice(device, UseExperimentalWasapi.Value);
+                bool alreadyInitialised = Bass.LastError == Errors.Already;
+
+                if (alreadyInitialised)
                     return true;
 
-                Logger.Log($"BASS device {device} failed to initialise with experimental WASAPI, disabling", level: LogLevel.Error);
-                UseExperimentalWasapi.Value = false;
-            }
+                if (BassUtils.CheckFaulted(false))
+                    return false;
+
+                if (!innerSuccess)
+                {
+                    Logger.Log("BASS failed to initialize but did not provide an error code", level: LogLevel.Error);
+                    return false;
+                }
+
+                var deviceInfo = audioDevices.ElementAtOrDefault(device);
 
-            return thread.InitDevice(device, false);
+                Logger.Log($@"🔈 BASS initialised
+                          BASS version:           {Bass.Version}
+                          BASS FX version:        {BassFx.Version}
+                          BASS MIX version:       {BassMix.Version}
+                          Device:                 {deviceInfo.Name}
+                          Driver:                 {deviceInfo.Driver}
+                          Update period:          {Bass.UpdatePeriod} ms
+                          Device buffer length:   {Bass.DeviceBufferLength} ms
+                          Playback buffer length: {Bass.PlaybackBufferLength} ms");
+
+                return true;
+            }
         }
 
         private void syncAudioDevices()
@@ -460,7 +461,14 @@ private void syncAudioDevices()
             var oldDeviceNames = audioDeviceNames;
             var newDeviceNames = audioDeviceNames = audioDevices.Skip(BASS_INTERNAL_DEVICE_COUNT).Where(d => d.IsEnabled).Select(d => d.Name).ToImmutableList();
 
-            onDevicesChanged();
+            scheduler.Add(() =>
+            {
+                if (cancelSource.IsCancellationRequested)
+                    return;
+
+                if (!IsCurrentDeviceValid())
+                    initCurrentDevice();
+            }, false);
 
             var newDevices = newDeviceNames.Except(oldDeviceNames).ToList();
             var lostDevices = oldDeviceNames.Except(newDeviceNames).ToList();

osu.Framework/Audio/Mixing/Bass/BassAudioMixer.cs

@@ -261,15 +261,9 @@ public bool StreamFree(IBassAudioChannel channel)
 
         public void UpdateDevice(int deviceIndex)
         {
-            if (Handle == 0)
-                createMixer();
-            else
-            {
-                ManagedBass.Bass.ChannelSetDevice(Handle, deviceIndex);
-
-                if (manager?.GlobalMixerHandle.Value != null)
-                    BassMix.MixerAddChannel(manager.GlobalMixerHandle.Value.Value, Handle, BassFlags.MixerChanBuffer | BassFlags.MixerChanNoRampin);
-            }
+            // It's important that we re-create the mixer after a device change.
+            // The mixer may need to be initialised with different flags depending on the state of global mixer usage.
+            createMixer();
         }
 
         protected override void UpdateState()
@@ -291,14 +285,15 @@ protected override void UpdateState()
         private void createMixer()
         {
             if (Handle != 0)
-                return;
+                ManagedBass.Bass.StreamFree(Handle);
 
             // Make sure that bass is initialised before trying to create a mixer.
             // If not, this will be called again when the device is initialised via UpdateDevice().
             if (!ManagedBass.Bass.GetDeviceInfo(ManagedBass.Bass.CurrentDevice, out var deviceInfo) || !deviceInfo.IsInitialized)
                 return;
 
             Handle = manager?.GlobalMixerHandle.Value != null
+                // The decode flag here is super important to maintain the lowest latency audio output.
                 ? BassMix.CreateMixerStream(frequency, 2, BassFlags.MixerNonStop | BassFlags.Decode)
                 : BassMix.CreateMixerStream(frequency, 2, BassFlags.MixerNonStop);
 

osu.Framework/Game.cs

@@ -188,19 +188,12 @@ private void load(FrameworkConfigManager config)
             samples.AddStore(new NamespacedResourceStore<byte[]>(Resources, @"Samples"));
             samples.AddStore(CreateOnlineStore());
 
-            Audio = new AudioManager(Host.AudioThread, tracks, samples) { EventScheduler = Scheduler };
+            Audio = new AudioManager(Host.AudioThread, tracks, samples, config) { EventScheduler = Scheduler };
             dependencies.Cache(Audio);
 
             dependencies.CacheAs(Audio.Tracks);
             dependencies.CacheAs(Audio.Samples);
 
-            // attach our bindables to the audio subsystem.
-            config.BindWith(FrameworkSetting.AudioDevice, Audio.AudioDevice);
-            config.BindWith(FrameworkSetting.AudioUseExperimentalWasapi, Audio.UseExperimentalWasapi);
-            config.BindWith(FrameworkSetting.VolumeUniversal, Audio.Volume);
-            config.BindWith(FrameworkSetting.VolumeEffect, Audio.VolumeSample);
-            config.BindWith(FrameworkSetting.VolumeMusic, Audio.VolumeTrack);
-
             Shaders = new ShaderManager(Host.Renderer, new NamespacedResourceStore<byte[]>(Resources, @"Shaders"));
             dependencies.Cache(Shaders);
 

osu.Framework/Threading/AudioThread.cs

@@ -141,6 +141,8 @@ internal bool InitDevice(int deviceId, bool useExperimentalWasapi)
 
             if (useExperimentalWasapi)
                 attemptWasapiInitialisation();
+            else
+                freeWasapi();
 
             initialised_devices.Add(deviceId);
             return true;