Merge pull request #472 from egyzol/detect-device-change

Detect audio device changes crossplatform

Author: Dextinfire

CMakeLists.txt

@@ -1003,6 +1003,7 @@ if (EMSCRIPTEN)
     string(REPLACE "-O2" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
     string(REPLACE "-O2" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
     string(REPLACE "-O2" "" CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
+    add_definitions(-DIMPACTO_OPENAL_HAVE_ALEXT)
 else ()
     find_package(SDL2 CONFIG REQUIRED)
     find_package(ZLIB REQUIRED)
@@ -1028,6 +1029,7 @@ else ()
             drm_nouveau
             nx
         )
+        add_definitions(-DIMPACTO_OPENAL_HAVE_ALEXT)
     else ()
         find_package(Ogg CONFIG REQUIRED)
         find_package(Vorbis CONFIG REQUIRED)

src/audio/audiobackend.h

@@ -9,7 +9,13 @@ class AudioBackend {
  public:
   virtual bool Init() { return true; };
 
+  virtual bool Reinit() { return true; };
+
   virtual void Shutdown() {};
+
+  virtual bool DidDeviceChanged() { return false; };
+
+  virtual bool ReopenSupported() { return false; }
 };
 
 }  // namespace Audio

src/audio/audiochannel.h

@@ -25,6 +25,7 @@ class AudioChannel {
   virtual void Stop(float fadeOutDuration) = 0;
   virtual void Pause() = 0;
   virtual void Resume() = 0;
+  virtual void Reinit() = 0;
 
   virtual void Update(float dt) = 0;
   virtual float PositionInSeconds() const = 0;
@@ -82,6 +83,8 @@ class EmptyAudioChannel : public AudioChannel {
     if (State == ACS_Paused) State = ACS_Playing;
   }
 
+  void Reinit() override {}
+
   void Update(float dt) override {}
 
   float PositionInSeconds() const override { return 0; }

src/audio/audiosystem.cpp

@@ -190,6 +190,22 @@ void AudioInit() {
   IsInit = true;
 }
 
+void AudioReinit() {
+  if (Backend->Reinit()) {
+    ImpLog(LogLevel::Info, LogChannel::Audio, "Reinitializing audio system\n");
+    if (Backend->ReopenSupported()) return;
+  }
+
+  for (int i = AC_SE0; i <= AC_SE2; i++) Channels[i]->Reinit();
+  for (int i = AC_VOICE0; i <= AC_REV; i++) Channels[i]->Reinit();
+  for (int i = AC_BGM0; i <= AC_BGM2; i++) Channels[i]->Reinit();
+
+  Channels[AC_SSE0]->Reinit();
+  Channels[AC_SSE1]->Reinit();
+  Channels[AC_SSE2]->Reinit();
+  Channels[AC_SSE3]->Reinit();
+}
+
 void AudioSubtitlesStart(AudioChannel* channel) {
   using Profile::Subtitle::SubtitleMappings;
   std::optional<Subtitle::SubtitlePlayer> player;

src/audio/audiosystem.h

@@ -14,6 +14,7 @@ namespace Audio {
 void AudioInit();
 void AudioUpdate(float dt);
 void AudioShutdown();
+void AudioReinit();
 
 void AudioSubtitlesStart(AudioChannel* channel);
 void AudioSubtitlesUpdate();

src/audio/ffmpegaudioplayer.h

@@ -19,6 +19,7 @@ class FFmpegAudioPlayer {
   virtual void InitConvertContext(AVCodecContext* codecCtx) {};
   virtual void FillAudioBuffers() {};
   virtual void Process() {};
+  virtual void Reinit() {};
 
   virtual void Stop() {};
   virtual void Unload() {};

src/audio/openal/audiobackend.cpp

@@ -8,6 +8,19 @@ namespace OpenAL {
 
 static ALCdevice* AlcDevice = 0;
 static ALCcontext* AlcContext = 0;
+static bool IsReopenSupported = false;
+#if ALC_SOFT_system_events
+static LPALCEVENTCALLBACKSOFT EventCallBackFunc = 0;
+static LPALCEVENTCONTROLSOFT EventControlFunc = 0;
+#endif
+#if ALC_SOFT_reopen_device
+static LPALCREOPENDEVICESOFT ReopenSoftFunc = 0;
+#endif
+void AL_APIENTRY DefaultDeviceChangedEventCallback(
+    ALCenum eventType, ALCenum deviceType, ALCdevice* device, ALCsizei length,
+    const ALCchar* message, void* userParam) {
+  *(bool*)userParam = true;
+}
 
 bool AudioBackend::Init() {
   AlcDevice = alcOpenDevice(NULL);
@@ -16,10 +29,41 @@ bool AudioBackend::Init() {
            "Could not create OpenAL device\n");
     return false;
   }
+  AlcContext = alcCreateContext(AlcDevice, NULL);
+  if (!AlcContext || !alcMakeContextCurrent(AlcContext)) {
+    ImpLog(LogLevel::Fatal, LogChannel::Audio,
+           "Failed to create OpenAL context\n");
+    alcCloseDevice(AlcDevice);
+    return false;
+  }
   if (alIsExtensionPresent("AL_EXT_float32") == AL_FALSE) {
     ImpLog(LogLevel::Error, LogChannel::Audio,
            "No floating-point audio support, some decoders may fail\n");
   }
+  InitAlextFunctions();
+  return true;
+}
+
+bool AudioBackend::Reinit() {
+  DeviceChanged = false;
+#if ALC_SOFT_reopen_device
+  if (IsReopenSupported) {
+    if (ReopenSoftFunc) {
+      return ReopenSoftFunc(AlcDevice, NULL, NULL);
+    } else {
+      ImpLog(LogLevel::Error, LogChannel::Audio,
+             "Reopen support is present but function was not found falling "
+             "back to manual reopen\n");
+    }
+  }
+#endif
+  Shutdown();
+  AlcDevice = alcOpenDevice(NULL);
+  if (!AlcDevice) {
+    ImpLog(LogLevel::Fatal, LogChannel::Audio,
+           "Could not create OpenAL device\n");
+    return false;
+  }
   AlcContext = alcCreateContext(AlcDevice, NULL);
   if (!AlcContext || !alcMakeContextCurrent(AlcContext)) {
     ImpLog(LogLevel::Fatal, LogChannel::Audio,
@@ -35,6 +79,49 @@ void AudioBackend::Shutdown() {
   if (AlcDevice) alcCloseDevice(AlcDevice);
 }
 
+bool AudioBackend::DidDeviceChanged() { return DeviceChanged; }
+
+bool AudioBackend::ReopenSupported() {
+#if ALC_SOFT_reopen_device
+  return IsReopenSupported && ReopenSoftFunc && EventControlFunc &&
+         EventCallBackFunc;
+#else
+  return false;
+#endif
+}
+
+void AudioBackend::InitAlextFunctions() {
+#if ALC_SOFT_system_events
+  if (alcIsExtensionPresent(AlcDevice, "ALC_SOFT_system_events") == AL_TRUE) {
+    EventControlFunc = (LPALCEVENTCONTROLSOFT)alcGetProcAddress(
+        AlcDevice, "alcEventControlSOFT");
+    if (EventControlFunc) {
+      const ALCenum eventType{ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT};
+      EventControlFunc(1, &eventType, AL_TRUE);
+    }
+
+    EventCallBackFunc = (LPALCEVENTCALLBACKSOFT)alcGetProcAddress(
+        AlcDevice, "alcEventCallbackSOFT");
+    if (EventCallBackFunc) {
+      EventCallBackFunc((ALCEVENTPROCTYPESOFT)DefaultDeviceChangedEventCallback,
+                        &DeviceChanged);
+    }
+#if ALC_SOFT_reopen_device
+    if (alcIsExtensionPresent(AlcDevice, "ALC_SOFT_reopen_device") ==
+        AL_FALSE) {
+      ImpLog(LogLevel::Error, LogChannel::Audio,
+             "No device reopen support,will be done manually\n");
+    } else {
+      IsReopenSupported = true;
+      ReopenSoftFunc = (LPALCREOPENDEVICESOFT)alcGetProcAddress(
+          AlcDevice, "alcReopenDeviceSOFT");
+      if (!ReopenSoftFunc) IsReopenSupported = false;
+    }
+#endif
+  }
+#endif
+}
+
 };  // namespace OpenAL
 };  // namespace Audio
 };  // namespace Impacto

src/audio/openal/audiobackend.h

@@ -8,10 +8,20 @@ namespace Audio {
 namespace OpenAL {
 
 class AudioBackend : public Audio::AudioBackend {
+ private:
+  bool DeviceChanged = false;
+  void InitAlextFunctions();
+
  public:
   bool Init() override;
 
+  bool Reinit() override;
+
   void Shutdown() override;
+
+  bool DidDeviceChanged() override;
+
+  bool ReopenSupported() override;
 };
 
 }  // namespace OpenAL

src/audio/openal/ffmpegaudioplayer.cpp

@@ -37,6 +37,18 @@ void FFmpegAudioPlayer::Init() {
   alGenBuffers(AudioBufferCount, BufferIds);
 }
 
+void FFmpegAudioPlayer::Reinit() {
+  alGenSources(1, &ALSource);
+  alSourcef(ALSource, AL_PITCH, 1);
+  alSourcef(ALSource, AL_GAIN, 1);
+  alSource3f(ALSource, AL_POSITION, 0, 0, 0);
+  alSource3f(ALSource, AL_VELOCITY, 0, 0, 0);
+  alSourcei(ALSource, AL_LOOPING, AL_FALSE);
+
+  alGenBuffers(AudioBufferCount, BufferIds);
+  First = true;
+}
+
 void FFmpegAudioPlayer::InitConvertContext(AVCodecContext* codecCtx) {
   AVChannelLayout stereoFormat;
   av_channel_layout_default(&stereoFormat, 2);
@@ -126,6 +138,7 @@ void FFmpegAudioPlayer::Process() {
     alGetSourcei(ALSource, AL_BUFFERS_PROCESSED, &FreeBufferCount);
     if (First) {
       FreeBufferCount = AudioBufferCount;
+      FirstFreeBuffer = 0;
     }
 
     int currentlyPlayingBuffer =

src/audio/openal/ffmpegaudioplayer.h

@@ -18,6 +18,7 @@ class FFmpegAudioPlayer : public Audio::FFmpegAudioPlayer {
   void InitConvertContext(AVCodecContext* codecCtx) override;
   void FillAudioBuffers() override;
   void Process() override;
+  void Reinit() override;
 
   void Stop() override;
   void Unload() override;