add per user volume slider

res/css/application-low-priority.css

@@ -87,3 +87,11 @@ has to be separate to allow main.css to override certain things
 .app-window colorswatch {
     box-shadow: 0 1px rgba(0, 0, 0, 0);
 }
+
+.app-window scale {
+    padding-top: 0px;
+    padding-bottom: 0px;
+    margin-top: 0px;
+    margin-bottom: 0px;
+    color: @text_color;
+}

src/abaddon.cpp

@@ -438,6 +438,12 @@ void Abaddon::OnVoiceConnected() {
         }
     });
 
+    wnd->signal_user_volume_changed().connect([this](Snowflake id, double volume) {
+        if (const auto ssrc = m_discord.GetSSRCOfUser(id); ssrc.has_value()) {
+            m_audio->SetVolumeSSRC(*ssrc, volume);
+        }
+    });
+
     wnd->show();
     wnd->signal_hide().connect([this, wnd]() {
         m_discord.DisconnectFromVoice();

src/audio/manager.cpp

@@ -28,13 +28,18 @@ void data_callback(ma_device *pDevice, void *pOutput, const void *pInput, ma_uin
     AudioManager *mgr = reinterpret_cast<AudioManager *>(pDevice->pUserData);
     if (mgr == nullptr) return;
     std::lock_guard<std::mutex> _(mgr->m_mutex);
+    std::lock_guard<std::mutex> _2(mgr->m_volume_ssrc_mutex);
 
     auto *pOutputF32 = static_cast<float *>(pOutput);
     for (auto &[ssrc, pair] : mgr->m_sources) {
+        double volume = 1.0;
+        if (const auto vol_it = mgr->m_volume_ssrc.find(ssrc); vol_it != mgr->m_volume_ssrc.end()) {
+            volume = vol_it->second;
+        }
         auto &buf = pair.first;
         const size_t n = std::min(static_cast<size_t>(buf.size()), static_cast<size_t>(frameCount * 2ULL));
         for (size_t i = 0; i < n; i++) {
-            pOutputF32[i] += buf[i] / 32768.F;
+            pOutputF32[i] += volume * buf[i] / 32768.F;
         }
         buf.erase(buf.begin(), buf.begin() + n);
     }
@@ -180,6 +185,13 @@ void AudioManager::SetMuteSSRC(uint32_t ssrc, bool mute) {
     }
 }
 
+void AudioManager::SetVolumeSSRC(uint32_t ssrc, double volume) {
+    std::lock_guard<std::mutex> _(m_volume_ssrc_mutex);
+    volume *= 0.01;
+    constexpr const double E = 2.71828182845904523536;
+    m_volume_ssrc[ssrc] = (std::exp(volume) - 1) / (E - 1);
+}
+
 void AudioManager::OnCapturedPCM(const int16_t *pcm, ma_uint32 frames) {
     if (m_opus_buffer == nullptr || !m_should_capture) return;
 

src/audio/manager.hpp

@@ -31,6 +31,7 @@ public:
     void SetPlayback(bool playback);
 
     void SetMuteSSRC(uint32_t ssrc, bool mute);
+    void SetVolumeSSRC(uint32_t ssrc, double volume);
 
     [[nodiscard]] bool OK() const;
 
@@ -62,8 +63,10 @@ private:
     std::atomic<bool> m_should_playback = true;
 
     std::unordered_set<uint32_t> m_muted_ssrcs;
+    std::unordered_map<uint32_t, double> m_volume_ssrc;
 
     mutable std::mutex m_muted_ssrc_mutex;
+    mutable std::mutex m_volume_ssrc_mutex;
 
 public:
     using type_signal_opus_packet = sigc::signal<void(int payload_size)>;

src/windows/voicewindow.cpp

@@ -10,16 +10,26 @@
 class VoiceWindowUserListEntry : public Gtk::ListBoxRow {
 public:
     VoiceWindowUserListEntry(Snowflake id)
-        : m_main(Gtk::ORIENTATION_HORIZONTAL)
+        : m_main(Gtk::ORIENTATION_VERTICAL)
+        , m_horz(Gtk::ORIENTATION_HORIZONTAL)
         , m_avatar(32, 32)
         , m_mute("Mute") {
         m_name.set_halign(Gtk::ALIGN_START);
         m_name.set_hexpand(true);
         m_mute.set_halign(Gtk::ALIGN_END);
 
-        m_main.add(m_avatar);
-        m_main.add(m_name);
-        m_main.add(m_mute);
+        m_volume.set_range(0.0, 200.0);
+        m_volume.set_value_pos(Gtk::POS_LEFT);
+        m_volume.set_value(100.0);
+        m_volume.signal_value_changed().connect([this]() {
+            m_signal_volume.emit(m_volume.get_value());
+        });
+
+        m_horz.add(m_avatar);
+        m_horz.add(m_name);
+        m_horz.add(m_mute);
+        m_main.add(m_horz);
+        m_main.add(m_volume);
         add(m_main);
         show_all_children();
 
@@ -38,18 +48,26 @@ public:
 
 private:
     Gtk::Box m_main;
+    Gtk::Box m_horz;
     LazyImage m_avatar;
     Gtk::Label m_name;
     Gtk::CheckButton m_mute;
+    Gtk::Scale m_volume;
 
 public:
     using type_signal_mute_cs = sigc::signal<void(bool)>;
+    using type_signal_volume = sigc::signal<void(double)>;
     type_signal_mute_cs signal_mute_cs() {
         return m_signal_mute_cs;
     }
 
+    type_signal_volume signal_volume() {
+        return m_signal_volume;
+    }
+
 private:
     type_signal_mute_cs m_signal_mute_cs;
+    type_signal_volume m_signal_volume;
 };
 
 VoiceWindow::VoiceWindow(Snowflake channel_id)
@@ -82,6 +100,9 @@ void VoiceWindow::SetUsers(const std::unordered_set<Snowflake> &user_ids) {
         row->signal_mute_cs().connect([this, id](bool is_muted) {
             m_signal_mute_user_cs.emit(id, is_muted);
         });
+        row->signal_volume().connect([this, id](double volume) {
+            m_signal_user_volume_changed.emit(id, volume);
+        });
         m_user_list.add(*row);
     }
 }
@@ -105,4 +126,8 @@ VoiceWindow::type_signal_deafen VoiceWindow::signal_deafen() {
 VoiceWindow::type_signal_mute_user_cs VoiceWindow::signal_mute_user_cs() {
     return m_signal_mute_user_cs;
 }
+
+VoiceWindow::type_signal_user_volume_changed VoiceWindow::signal_user_volume_changed() {
+    return m_signal_user_volume_changed;
+}
 #endif

src/windows/voicewindow.hpp

@@ -34,14 +34,17 @@ public:
     using type_signal_mute = sigc::signal<void(bool)>;
     using type_signal_deafen = sigc::signal<void(bool)>;
     using type_signal_mute_user_cs = sigc::signal<void(Snowflake, bool)>;
+    using type_signal_user_volume_changed = sigc::signal<void(Snowflake, double)>;
 
     type_signal_mute signal_mute();
     type_signal_deafen signal_deafen();
     type_signal_mute_user_cs signal_mute_user_cs();
+    type_signal_user_volume_changed signal_user_volume_changed();
 
 private:
     type_signal_mute m_signal_mute;
     type_signal_deafen m_signal_deafen;
     type_signal_mute_user_cs m_signal_mute_user_cs;
+    type_signal_user_volume_changed m_signal_user_volume_changed;
 };
 #endif