Refactor audio handling

CMakeLists.txt

@@ -49,6 +49,14 @@ file(GLOB_RECURSE ABADDON_SOURCES
 list(FILTER ABADDON_SOURCES EXCLUDE REGEX ".*notifier_gio\\.cpp$")
 list(FILTER ABADDON_SOURCES EXCLUDE REGEX ".*notifier_fallback\\.cpp$")
 
+if (NOT ENABLE_VOICE)
+    list(FILTER ABADDON_SOURCES EXCLUDE REGEX "src/audio/voice/.*")
+endif ()
+
+if (NOT (ENABLE_VOICE OR ENABLE_NOTIFICATION_SOUNDS))
+    list(FILTER ABADDON_SOURCES EXCLUDE REGEX "src/audio/.*")
+endif ()
+
 add_executable(abaddon ${ABADDON_SOURCES})
 target_include_directories(abaddon PUBLIC ${PROJECT_SOURCE_DIR}/src)
 target_include_directories(abaddon PUBLIC ${PROJECT_BINARY_DIR})
@@ -220,3 +228,10 @@ set(ABADDON_COMPILER_DEFS "" CACHE STRING "Additional compiler definitions")
 foreach (COMPILER_DEF IN LISTS ABADDON_COMPILER_DEFS)
     target_compile_definitions(abaddon PRIVATE "${COMPILER_DEF}")
 endforeach ()
+
+# LTO breaks on Windows
+# Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108383
+# And other weirdness
+if (NOT WIN32)
+    set_property(TARGET abaddon PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif ()

README.md

@@ -338,10 +338,11 @@ For example, memory_db would be set by adding `memory_db = true` under the line
 
 #### voice
 
-| Setting    | Type   | Default                            | Description                                                                                                                |
-|------------|--------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
-| `vad`      | string | rnnoise if enabled, gate otherwise | Method used for voice activity detection. Changeable in UI                                                                 |
-| `backends` | string | empty                              | Change backend priority when initializing miniaudio: `wasapi;dsound;winmm;coreaudio;sndio;audio4;oss;pulseaudio;alsa;jack` |
+| Setting            | Type    | Default                            | Description                                                                                                                |
+|--------------------|---------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
+| `vad`              | string  | rnnoise if enabled, gate otherwise | Method used for voice activity detection. Changeable in UI                                                                 |
+| `backends`         | string  | empty                              | Change backend priority when initializing miniaudio: `wasapi;dsound;winmm;coreaudio;sndio;audio4;oss;pulseaudio;alsa;jack` |
+| `separate_sources` | boolean | false                              | Spawn separate audio sources for each user in voice call, useful for multitrack recording on Linux                         |
 
 #### windows
 

src/abaddon.cpp

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <gtkmm.h>
 #include "platform.hpp"
-#include "audio/manager.hpp"
 #include "discord/discord.hpp"
 #include "dialogs/token.hpp"
 #include "dialogs/confirm.hpp"
@@ -50,12 +49,16 @@ void macOSThemeChangedCallback(CFNotificationCenterRef center, void *observer, C
 #pragma comment(lib, "crypt32.lib")
 #endif
 
+#ifdef WITH_MINIAUDIO
+#include "audio/manager.hpp"
+#endif
+
 Abaddon::Abaddon()
     : m_settings(Platform::FindConfigFile())
     , m_discord(GetSettings().UseMemoryDB) // stupid but easy
     , m_emojis(GetResPath("/emojis.db"))
-#ifdef WITH_VOICE
-    , m_audio(GetSettings().Backends)
+#ifdef WITH_MINIAUDIO
+    , m_audio(GetSettings().Backends, m_discord)
 #endif
 {
     LoadFromSettings();
@@ -81,10 +84,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 +102,7 @@ Abaddon::Abaddon()
     }
 
 #ifdef WITH_VOICE
-    m_audio.SetVADMethod(GetSettings().VAD);
+    m_audio.GetVoice().GetCapture().GetEffects().SetVADMethod(GetSettings().VAD);
 #endif
 }
 
@@ -487,43 +486,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 +1157,7 @@ EmojiResource &Abaddon::GetEmojis() {
     return m_emojis;
 }
 
-#ifdef WITH_VOICE
+#ifdef WITH_MINIAUDIO
 AudioManager &Abaddon::GetAudio() {
     return m_audio;
 }

src/abaddon.hpp

@@ -12,12 +12,13 @@
 #include "imgmanager.hpp"
 #include "emojis.hpp"
 #include "notifications/notifications.hpp"
+
+#ifdef WITH_MINIAUDIO
 #include "audio/manager.hpp"
+#endif
 
 #define APP_TITLE "Abaddon"
 
-class AudioManager;
-
 class Abaddon {
 private:
     Abaddon();
@@ -72,7 +73,7 @@ class Abaddon {
     ImageManager &GetImageManager();
     EmojiResource &GetEmojis();
 
-#ifdef WITH_VOICE
+#ifdef WITH_MINIAUDIO
     AudioManager &GetAudio();
 #endif
 
@@ -174,8 +175,11 @@ class Abaddon {
     ImageManager m_img_mgr;
     EmojiResource m_emojis;
 
-#ifdef WITH_VOICE
+#ifdef WITH_MINIAUDIO
     AudioManager m_audio;
+#endif
+
+#ifdef WITH_VOICE
     Gtk::Window *m_voice_window = nullptr;
 #endif
 

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,53 @@
+#include "audio_engine.hpp"
+
+#include <glibmm/main.h>
+#include <spdlog/spdlog.h>
+
+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();
+}
+
+}