AudioServer: Allow muting the system audio

This patch adds muting to ASMixer, which works by substituting what we
would normally send to the sound card with zero-filled memory instead.
We do it this way to ensure that the queued sample buffers keep getting
played (silently.)

This is obviously not the perfect way of doing this, and in the future
we should improve on this, and also find a way to utilize any hardware
mixing functions in the sound card.

Libraries/LibAudio/AClientConnection.cpp

@@ -32,6 +32,16 @@ bool AClientConnection::try_enqueue(const ABuffer& buffer)
     return response->success();
 }
 
+bool AClientConnection::get_muted()
+{
+    return send_sync<AudioServer::GetMuted>()->muted();
+}
+
+void AClientConnection::set_muted(bool muted)
+{
+    send_sync<AudioServer::SetMuted>(muted);
+}
+
 int AClientConnection::get_main_mix_volume()
 {
     return send_sync<AudioServer::GetMainMixVolume>()->volume();

Libraries/LibAudio/AClientConnection.h

@@ -14,6 +14,9 @@ public:
     void enqueue(const ABuffer&);
     bool try_enqueue(const ABuffer&);
 
+    bool get_muted();
+    void set_muted(bool);
+
     int get_main_mix_volume();
     void set_main_mix_volume(int);
 

Servers/AudioServer/ASClientConnection.cpp

@@ -104,9 +104,21 @@ OwnPtr<AudioServer::ClearBufferResponse> ASClientConnection::handle(const AudioS
     return make<AudioServer::ClearBufferResponse>();
 }
 
-OwnPtr<AudioServer::GetPlayingBufferResponse> ASClientConnection::handle(const AudioServer::GetPlayingBuffer&){
+OwnPtr<AudioServer::GetPlayingBufferResponse> ASClientConnection::handle(const AudioServer::GetPlayingBuffer&)
+{
     int id = -1;
     if (m_queue)
         id = m_queue->get_playing_buffer();
     return make<AudioServer::GetPlayingBufferResponse>(id);
 }
+
+OwnPtr<AudioServer::GetMutedResponse> ASClientConnection::handle(const AudioServer::GetMuted&)
+{
+    return make<AudioServer::GetMutedResponse>(m_mixer.is_muted());
+}
+
+OwnPtr<AudioServer::SetMutedResponse> ASClientConnection::handle(const AudioServer::SetMuted& message)
+{
+    m_mixer.set_muted(message.muted());
+    return make<AudioServer::SetMutedResponse>();
+}

Servers/AudioServer/ASClientConnection.h

@@ -27,6 +27,8 @@ private:
     virtual OwnPtr<AudioServer::SetPausedResponse> handle(const AudioServer::SetPaused&) override;
     virtual OwnPtr<AudioServer::ClearBufferResponse> handle(const AudioServer::ClearBuffer&) override;
     virtual OwnPtr<AudioServer::GetPlayingBufferResponse> handle(const AudioServer::GetPlayingBuffer&) override;
+    virtual OwnPtr<AudioServer::GetMutedResponse> handle(const AudioServer::GetMuted&) override;
+    virtual OwnPtr<AudioServer::SetMutedResponse> handle(const AudioServer::SetMuted&) override;
 
     ASMixer& m_mixer;
     RefPtr<ASBufferQueue> m_queue;

Servers/AudioServer/ASMixer.cpp

@@ -15,6 +15,8 @@ ASMixer::ASMixer()
         return;
     }
 
+    m_zero_filled_buffer = (u8*)malloc(4096);
+    bzero(m_zero_filled_buffer, 4096);
     m_sound_thread.start();
 }
 
@@ -66,11 +68,14 @@ void ASMixer::mix()
             }
         }
 
+        bool muted = m_muted;
+
         // output the mixed stuff to the device
         u8 raw_buffer[4096];
-        auto buffer = ByteBuffer::wrap(raw_buffer, sizeof(raw_buffer));
-        BufferStream stream(buffer);
+        auto buffer = ByteBuffer::wrap(muted ? m_zero_filled_buffer : raw_buffer, sizeof(raw_buffer));
 
+        BufferStream stream(buffer);
+        if (!muted) {
             for (int i = 0; i < mixed_buffer_length; ++i) {
                 auto& mixed_sample = mixed_buffer[i];
 
@@ -85,12 +90,18 @@ void ASMixer::mix()
                 out_sample = mixed_sample.right * std::numeric_limits<i16>::max();
                 stream << out_sample;
             }
+        }
 
         if (stream.offset() != 0) {
             buffer.trim(stream.offset());
+        }
         m_device->write(buffer);
     }
 }
+
+void ASMixer::set_muted(bool muted)
+{
+    m_muted = muted;
 }
 
 ASBufferQueue::ASBufferQueue(ASClientConnection& client)

Servers/AudioServer/ASMixer.h

@@ -87,6 +87,9 @@ public:
     int main_volume() const { return m_main_volume; }
     void set_main_volume(int volume) { m_main_volume = volume; }
 
+    bool is_muted() const { return m_muted; }
+    void set_muted(bool);
+
 private:
     Vector<NonnullRefPtr<ASBufferQueue>> m_pending_mixing;
 
@@ -95,7 +98,10 @@ private:
 
     LibThread::Thread m_sound_thread;
 
+    bool m_muted { false };
     int m_main_volume { 100 };
 
+    u8* m_zero_filled_buffer { nullptr };
+
     void mix();
 };

Servers/AudioServer/AudioServer.ipc

@@ -4,6 +4,8 @@ endpoint AudioServer
     Greet(i32 client_pid) => (i32 server_pid, i32 client_id)
 
     // Mixer functions
+    SetMuted(bool muted) => ()
+    GetMuted() => (bool muted)
     GetMainMixVolume() => (i32 volume)
     SetMainMixVolume(i32 volume) => ()
 

Userland/avol.cpp

@@ -9,6 +9,17 @@ int main(int argc, char** argv)
     audio_client->handshake();
 
     if (argc > 1) {
+        if (String(argv[1]) == "-m") {
+            audio_client->set_muted(true);
+            printf("Muted.\n");
+            return 0;
+        }
+        if (String(argv[1]) == "-M") {
+            audio_client->set_muted(false);
+            printf("Unmuted.\n");
+            return 0;
+        }
+
         int new_volume = atoi(argv[1]);
         audio_client->set_main_mix_volume(new_volume);
     }