Refactor audio handling

src/abaddon.cpp

@@ -55,7 +55,7 @@ Abaddon::Abaddon()
     , m_discord(GetSettings().UseMemoryDB) // stupid but easy
     , m_emojis(GetResPath("/emojis.db"))
 #ifdef WITH_VOICE
-    , m_audio(GetSettings().Backends)
+    , m_audio(GetSettings().Backends, m_discord)
 #endif
 {
     LoadFromSettings();
@@ -81,10 +81,6 @@ Abaddon::Abaddon()
 #ifdef WITH_VOICE
     m_discord.signal_voice_connected().connect(sigc::mem_fun(*this, &Abaddon::OnVoiceConnected));
     m_discord.signal_voice_disconnected().connect(sigc::mem_fun(*this, &Abaddon::OnVoiceDisconnected));
-    m_discord.signal_voice_speaking().connect([this](const VoiceSpeakingData &m) {
-        spdlog::get("voice")->debug("{} SSRC: {}", m.UserID, m.SSRC);
-        m_audio.AddSSRC(m.SSRC);
-    });
 #endif
 
     m_discord.signal_channel_accessibility_changed().connect([this](Snowflake id, bool accessible) {
@@ -103,7 +99,7 @@ Abaddon::Abaddon()
     }
 
 #ifdef WITH_VOICE
-    m_audio.SetVADMethod(GetSettings().VAD);
+    m_audio.GetVoice().GetCapture().GetEffects().SetVADMethod(GetSettings().VAD);
 #endif
 }
 
@@ -487,43 +483,72 @@ void Abaddon::DiscordOnThreadUpdate(const ThreadUpdateData &data) {
 
 #ifdef WITH_VOICE
 void Abaddon::OnVoiceConnected() {
-    m_audio.StartCaptureDevice();
     ShowVoiceWindow();
 }
 
 void Abaddon::OnVoiceDisconnected() {
-    m_audio.StopCaptureDevice();
-    m_audio.RemoveAllSSRCs();
     if (m_voice_window != nullptr) {
         m_voice_window->close();
     }
 }
 
 void Abaddon::ShowVoiceWindow() {
+    using SystemSound = AbaddonClient::Audio::SystemAudio::SystemSound;
+
     if (m_voice_window != nullptr) return;
 
     auto *wnd = new VoiceWindow(m_discord.GetVoiceChannelID());
     m_voice_window = wnd;
 
     wnd->signal_mute().connect([this](bool is_mute) {
         m_discord.SetVoiceMuted(is_mute);
-        m_audio.SetCapture(!is_mute);
+        m_audio.GetVoice().GetCapture().SetActive(!is_mute);
+
+        auto sound = is_mute ? SystemSound::VoiceMuted : SystemSound::VoiceUnmuted;
+        m_audio.GetSystem().PlaySound(sound);
     });
 
     wnd->signal_deafen().connect([this](bool is_deaf) {
         m_discord.SetVoiceDeafened(is_deaf);
-        m_audio.SetPlayback(!is_deaf);
+        m_audio.GetVoice().GetPlayback().SetActive(!is_deaf);
+
+        auto sound = is_deaf ? SystemSound::VoiceDeafened : SystemSound::VoiceUndeafened;
+        m_audio.GetSystem().PlaySound(sound);
     });
 
     wnd->signal_mute_user_cs().connect([this](Snowflake id, bool is_mute) {
         if (const auto ssrc = m_discord.GetSSRCOfUser(id); ssrc.has_value()) {
-            m_audio.SetMuteSSRC(*ssrc, is_mute);
+            m_audio.GetVoice().GetPlayback().GetClientStore().SetClientMute(*ssrc, is_mute);
         }
     });
 
     wnd->signal_user_volume_changed().connect([this](Snowflake id, double volume) {
         auto &vc = m_discord.GetVoiceClient();
         vc.SetUserVolume(id, volume);
+
+        if (const auto ssrc = m_discord.GetSSRCOfUser(id); ssrc.has_value()) {
+            m_audio.GetVoice().GetPlayback().GetClientStore().SetClientVolume(*ssrc, volume);
+        }
+    });
+
+    wnd->signal_playback_device_changed().connect([this](const Gtk::TreeModel::iterator &iter) {
+        auto device_id = m_audio.GetDevices().GetPlaybackDeviceIDFromModel(iter);
+        if (!device_id) {
+            spdlog::get("audio")->error("Requested ID from iterator is invalid");
+            return;
+        }
+
+        m_audio.GetVoice().GetPlayback().SetPlaybackDevice(*device_id);
+    });
+
+    wnd->signal_capture_device_changed().connect([this](const Gtk::TreeModel::iterator &iter) {
+        auto device_id = m_audio.GetDevices().GetCaptureDeviceIDFromModel(iter);
+        if (!device_id) {
+            spdlog::get("audio")->error("Requested ID from iterator is invalid");
+            return;
+        }
+
+        m_audio.GetVoice().GetCapture().SetCaptureDevice(*device_id);
     });
 
     wnd->set_position(Gtk::WIN_POS_CENTER);
@@ -1129,7 +1154,7 @@ EmojiResource &Abaddon::GetEmojis() {
     return m_emojis;
 }
 
-#ifdef WITH_VOICE
+#ifdef WITH_MINIAUDIO
 AudioManager &Abaddon::GetAudio() {
     return m_audio;
 }

src/audio/audio_device.cpp

@@ -0,0 +1,90 @@
+#include "audio_device.hpp"
+
+namespace AbaddonClient::Audio {
+
+AudioDevice::AudioDevice(Context &context, ma_device_config &&config, std::optional<ma_device_id> &&device_id) noexcept :
+    m_context(context),
+    m_config(std::move(config)),
+    m_device_id(std::move(device_id))
+{
+    SyncDeviceID();
+}
+
+bool AudioDevice::Start() noexcept {
+    if (m_started) {
+        return true;
+    }
+
+    m_device = Miniaudio::MaDevice::Create(m_context.GetRaw(), m_config);
+    if (!m_device) {
+        return false;
+    }
+
+    m_started = m_device->Start();
+    if (!m_started) {
+        m_device.reset();
+    }
+
+    return m_started;
+}
+
+bool AudioDevice::Stop() noexcept {
+    if (!m_started) {
+        return true;
+    }
+
+    m_started = !m_device->Stop();
+
+    // If we're still running something went wrong
+    if (m_started) {
+        return false;
+    }
+
+    m_device.reset();
+    return true;
+}
+
+bool AudioDevice::ChangeDevice(const ma_device_id &device_id) noexcept {
+    m_device_id = device_id;
+
+    return RefreshDevice();
+}
+
+void AudioDevice::SyncDeviceID() noexcept {
+    if (!m_device_id) {
+        return;
+    }
+
+    auto& device_id = *m_device_id;
+
+    switch (m_config.deviceType) {
+        case ma_device_type_playback: {
+            m_config.playback.pDeviceID = &device_id;
+        } break;
+
+        case ma_device_type_capture: {
+            m_config.capture.pDeviceID = &device_id;
+        } break;
+
+        case ma_device_type_duplex: {
+            m_config.playback.pDeviceID = &device_id;
+            m_config.capture.pDeviceID = &device_id;
+        }
+
+        case ma_device_type_loopback: {
+            m_config.capture.pDeviceID = &device_id;
+        }
+    }
+}
+
+bool AudioDevice::RefreshDevice() noexcept {
+    m_device.reset();
+    if (m_started) {
+        m_started = false;
+        return Start();
+    }
+
+    return true;
+}
+
+}

src/audio/audio_device.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "context.hpp"
+
+#include "miniaudio/ma_device.hpp"
+
+namespace AbaddonClient::Audio {
+
+class AudioDevice {
+public:
+    AudioDevice(Context& context, ma_device_config &&config, std::optional<ma_device_id> &&device_id) noexcept;
+
+    bool Start() noexcept;
+    bool Stop() noexcept;
+
+    bool ChangeDevice(const ma_device_id &device_id) noexcept;
+private:
+    void SyncDeviceID() noexcept;
+    bool RefreshDevice() noexcept;
+
+    bool m_started = false;
+
+    Context &m_context;
+    std::optional<Miniaudio::MaDevice> m_device;
+
+    ma_device_config m_config;
+    std::optional<ma_device_id> m_device_id;
+};
+
+}

src/audio/audio_engine.cpp

@@ -0,0 +1,50 @@
+#include "audio_engine.hpp"
+
+namespace AbaddonClient::Audio {
+
+AudioEngine::AudioEngine(Context &context) noexcept :
+    m_context(context) {}
+
+AudioEngine::~AudioEngine() noexcept {
+    StopTimer();
+}
+
+bool AudioEngine::PlaySound(std::string_view file_path) noexcept {
+    StopTimer();
+
+    const auto result = m_engine.LockScope([this, &file_path](std::optional<Miniaudio::MaEngine> &engine) {
+        if (!engine) {
+            engine = Miniaudio::MaEngine::Create(m_context.GetEngineConfig());
+            if (!engine) {
+                return false;
+            }
+        }
+
+        return engine->PlaySound(file_path);
+    });
+
+    StartTimer();
+    return result;
+}
+
+void AudioEngine::StartTimer() noexcept {
+    // NOTE: I am not using g_timeout_add_seconds_once here since we want to own the source and destroy it manually
+    // g_source_remove throws an error on destroyed source
+    m_timer_source = g_timeout_source_new_seconds(5);
+
+    g_source_set_callback(m_timer_source, GSourceFunc(AudioEngine::TimeoutEngine), this, nullptr);
+    g_source_attach(m_timer_source, Glib::MainContext::get_default()->gobj());
+}
+
+void AudioEngine::StopTimer() noexcept {
+    if (m_timer_source != nullptr) {
+        g_source_destroy(m_timer_source);
+        g_source_unref(m_timer_source);
+    }
+}
+
+void AudioEngine::TimeoutEngine(AudioEngine &engine) noexcept {
+    engine.m_engine.Lock()->reset();
+}
+
+}

src/audio/audio_engine.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <glibmm/timer.h>
+
+#include "misc/mutex.hpp"
+
+#include "miniaudio/ma_engine.hpp"
+
+namespace AbaddonClient::Audio {
+
+class AudioEngine {
+public:
+    AudioEngine(Context& context) noexcept;
+    ~AudioEngine() noexcept;
+
+    bool PlaySound(std::string_view file_path) noexcept;
+private:
+    void StartTimer() noexcept;
+    void StopTimer() noexcept;
+
+    static void TimeoutEngine(AudioEngine &engine) noexcept;
+
+    Context &m_context;
+    Mutex<std::optional<Miniaudio::MaEngine>> m_engine;
+
+    GSource* m_timer_source;
+};
+
+}