LibAudio: Put all classes in the Audio namespace and remove leading A

Author: awesomekling

Applications/Piano/main.cpp

@@ -41,7 +41,7 @@ int main(int argc, char** argv)
 {
     GUI::Application app(argc, argv);
 
-    auto audio_client = AClientConnection::construct();
+    auto audio_client = Audio::ClientConnection::construct();
     audio_client->handshake();
 
     AudioEngine audio_engine;

Applications/SoundPlayer/PlaybackManager.cpp

@@ -26,7 +26,7 @@
 
 #include "PlaybackManager.h"
 
-PlaybackManager::PlaybackManager(NonnullRefPtr<AClientConnection> connection)
+PlaybackManager::PlaybackManager(NonnullRefPtr<Audio::ClientConnection> connection)
     : m_connection(connection)
 {
     m_timer = Core::Timer::construct(100, [&]() {
@@ -41,7 +41,7 @@ PlaybackManager::~PlaybackManager()
 {
 }
 
-void PlaybackManager::set_loader(OwnPtr<AWavLoader>&& loader)
+void PlaybackManager::set_loader(OwnPtr<Audio::WavLoader>&& loader)
 {
     stop();
     m_loader = move(loader);

Applications/SoundPlayer/PlaybackManager.h

@@ -36,22 +36,22 @@
 
 class PlaybackManager final {
 public:
-    PlaybackManager(NonnullRefPtr<AClientConnection>);
+    PlaybackManager(NonnullRefPtr<Audio::ClientConnection>);
     ~PlaybackManager();
 
     void play();
     void stop();
     void pause();
     void seek(const int position);
     bool toggle_pause();
-    void set_loader(OwnPtr<AWavLoader>&&);
+    void set_loader(OwnPtr<Audio::WavLoader>&&);
 
     int last_seek() const { return m_last_seek; }
     bool is_paused() const { return m_paused; }
     float total_length() const { return m_total_length; }
-    RefPtr<ABuffer> current_buffer() const { return m_current_buffer; }
+    RefPtr<Audio::Buffer> current_buffer() const { return m_current_buffer; }
 
-    NonnullRefPtr<AClientConnection> connection() const { return m_connection; }
+    NonnullRefPtr<Audio::ClientConnection> connection() const { return m_connection; }
 
     Function<void()> on_update;
 
@@ -65,10 +65,10 @@ class PlaybackManager final {
     int m_next_ptr { 0 };
     int m_last_seek { 0 };
     float m_total_length { 0 };
-    OwnPtr<AWavLoader> m_loader { nullptr };
-    NonnullRefPtr<AClientConnection> m_connection;
-    RefPtr<ABuffer> m_next_buffer;
-    RefPtr<ABuffer> m_current_buffer;
-    Vector<RefPtr<ABuffer>> m_buffers;
+    OwnPtr<Audio::WavLoader> m_loader { nullptr };
+    NonnullRefPtr<Audio::ClientConnection> m_connection;
+    RefPtr<Audio::Buffer> m_next_buffer;
+    RefPtr<Audio::Buffer> m_current_buffer;
+    Vector<RefPtr<Audio::Buffer>> m_buffers;
     RefPtr<Core::Timer> m_timer;
 };

Applications/SoundPlayer/SampleWidget.cpp

@@ -77,7 +77,7 @@ void SampleWidget::paint_event(GUI::PaintEvent& event)
     }
 }
 
-void SampleWidget::set_buffer(ABuffer* buffer)
+void SampleWidget::set_buffer(Audio::Buffer* buffer)
 {
     if (m_buffer == buffer)
         return;

Applications/SoundPlayer/SampleWidget.h

@@ -28,17 +28,19 @@
 
 #include <LibGUI/GFrame.h>
 
-class ABuffer;
+namespace Audio {
+class Buffer;
+}
 
 class SampleWidget final : public GUI::Frame {
     C_OBJECT(SampleWidget)
 public:
     virtual ~SampleWidget() override;
 
-    void set_buffer(ABuffer*);
+    void set_buffer(Audio::Buffer*);
 private:
     explicit SampleWidget(GUI::Widget* parent);
     virtual void paint_event(GUI::PaintEvent&) override;
 
-    RefPtr<ABuffer> m_buffer;
+    RefPtr<Audio::Buffer> m_buffer;
 };

Applications/SoundPlayer/SoundPlayerWidget.cpp

@@ -32,7 +32,7 @@
 #include <LibGUI/GMessageBox.h>
 #include <LibM/math.h>
 
-SoundPlayerWidget::SoundPlayerWidget(GUI::Window& window, NonnullRefPtr<AClientConnection> connection)
+SoundPlayerWidget::SoundPlayerWidget(GUI::Window& window, NonnullRefPtr<Audio::ClientConnection> connection)
     : m_window(window)
     , m_connection(connection)
     , m_manager(connection)
@@ -124,7 +124,7 @@ void SoundPlayerWidget::open_file(String path)
         return;
     }
 
-    OwnPtr<AWavLoader> loader = make<AWavLoader>(path);
+    OwnPtr<Audio::WavLoader> loader = make<Audio::WavLoader>(path);
     if (loader->has_error()) {
         GUI::MessageBox::show(
             String::format(

Applications/SoundPlayer/SoundPlayerWidget.h

@@ -43,7 +43,7 @@ class SoundPlayerWidget final : public GUI::Widget {
     PlaybackManager& manager() { return m_manager; }
 
 private:
-    explicit SoundPlayerWidget(GUI::Window&, NonnullRefPtr<AClientConnection>);
+    explicit SoundPlayerWidget(GUI::Window&, NonnullRefPtr<Audio::ClientConnection>);
 
     void update_position(const int position);
     void update_ui();
@@ -77,7 +77,7 @@ class SoundPlayerWidget final : public GUI::Widget {
     };
 
     GUI::Window& m_window;
-    NonnullRefPtr<AClientConnection> m_connection;
+    NonnullRefPtr<Audio::ClientConnection> m_connection;
     PlaybackManager m_manager;
     float m_sample_ratio;
     RefPtr<GUI::Label> m_status;

Applications/SoundPlayer/main.cpp

@@ -50,7 +50,7 @@ int main(int argc, char** argv)
         return 1;
     }
 
-    auto audio_client = AClientConnection::construct();
+    auto audio_client = Audio::ClientConnection::construct();
     audio_client->handshake();
 
     if (pledge("stdio shared_buffer accept rpath", nullptr) < 0) {

Libraries/LibAudio/ABuffer.h

@@ -31,24 +31,26 @@
 #include <AK/Vector.h>
 #include <AK/SharedBuffer.h>
 
+namespace Audio {
+
 // A single sample in an audio buffer.
 // Values are floating point, and should range from -1.0 to +1.0
-struct ASample {
-    ASample()
+struct Sample {
+    Sample()
         : left(0)
         , right(0)
     {
     }
 
     // For mono
-    ASample(float left)
+    Sample(float left)
         : left(left)
         , right(left)
     {
     }
 
     // For stereo
-    ASample(float left, float right)
+    Sample(float left, float right)
         : left(left)
         , right(right)
     {
@@ -74,7 +76,7 @@ struct ASample {
         right *= pct;
     }
 
-    ASample& operator+=(const ASample& other)
+    Sample& operator+=(const Sample& other)
     {
         left += other.left;
         right += other.right;
@@ -88,9 +90,9 @@ struct ASample {
 // Small helper to resample from one playback rate to another
 // This isn't really "smart", in that we just insert (or drop) samples.
 // Should do better...
-class AResampleHelper {
+class ResampleHelper {
 public:
-    AResampleHelper(float source, float target);
+    ResampleHelper(float source, float target);
 
     void process_sample(float sample_l, float sample_r);
     bool read_sample(float& next_l, float& next_r);
@@ -103,34 +105,34 @@ class AResampleHelper {
 };
 
 // A buffer of audio samples, normalized to 44100hz.
-class ABuffer : public RefCounted<ABuffer> {
+class Buffer : public RefCounted<Buffer> {
 public:
-    static RefPtr<ABuffer> from_pcm_data(ByteBuffer& data, AResampleHelper& resampler, int num_channels, int bits_per_sample);
-    static NonnullRefPtr<ABuffer> create_with_samples(Vector<ASample>&& samples)
+    static RefPtr<Buffer> from_pcm_data(ByteBuffer& data, ResampleHelper& resampler, int num_channels, int bits_per_sample);
+    static NonnullRefPtr<Buffer> create_with_samples(Vector<Sample>&& samples)
     {
-        return adopt(*new ABuffer(move(samples)));
+        return adopt(*new Buffer(move(samples)));
     }
-    static NonnullRefPtr<ABuffer> create_with_shared_buffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
+    static NonnullRefPtr<Buffer> create_with_shared_buffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
     {
-        return adopt(*new ABuffer(move(buffer), sample_count));
+        return adopt(*new Buffer(move(buffer), sample_count));
     }
 
-    const ASample* samples() const { return (const ASample*)data(); }
+    const Sample* samples() const { return (const Sample*)data(); }
     int sample_count() const { return m_sample_count; }
     const void* data() const { return m_buffer->data(); }
-    int size_in_bytes() const { return m_sample_count * (int)sizeof(ASample); }
+    int size_in_bytes() const { return m_sample_count * (int)sizeof(Sample); }
     int shared_buffer_id() const { return m_buffer->shared_buffer_id(); }
     SharedBuffer& shared_buffer() { return *m_buffer; }
 
 private:
-    explicit ABuffer(Vector<ASample>&& samples)
-        : m_buffer(*SharedBuffer::create_with_size(samples.size() * sizeof(ASample))),
+    explicit Buffer(Vector<Sample>&& samples)
+        : m_buffer(*SharedBuffer::create_with_size(samples.size() * sizeof(Sample))),
         m_sample_count(samples.size())
     {
-        memcpy(m_buffer->data(), samples.data(), samples.size() * sizeof(ASample));
+        memcpy(m_buffer->data(), samples.data(), samples.size() * sizeof(Sample));
     }
 
-    explicit ABuffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
+    explicit Buffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
         : m_buffer(move(buffer)),
         m_sample_count(sample_count)
     {
@@ -139,3 +141,5 @@ class ABuffer : public RefCounted<ABuffer> {
     NonnullRefPtr<SharedBuffer> m_buffer;
     const int m_sample_count;
 };
+
+}

Libraries/LibAudio/AClientConnection.cpp

@@ -28,88 +28,92 @@
 #include <LibAudio/ABuffer.h>
 #include <LibAudio/AClientConnection.h>
 
-AClientConnection::AClientConnection()
+namespace Audio {
+
+ClientConnection::ClientConnection()
     : IPC::ServerConnection<AudioClientEndpoint, AudioServerEndpoint>(*this, "/tmp/portal/audio")
 {
 }
 
-void AClientConnection::handshake()
+void ClientConnection::handshake()
 {
     auto response = send_sync<AudioServer::Greet>();
     set_my_client_id(response->client_id());
 }
 
-void AClientConnection::enqueue(const ABuffer& buffer)
+void ClientConnection::enqueue(const Buffer& buffer)
 {
     for (;;) {
-        const_cast<ABuffer&>(buffer).shared_buffer().share_with(server_pid());
+        const_cast<Buffer&>(buffer).shared_buffer().share_with(server_pid());
         auto response = send_sync<AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
         if (response->success())
             break;
         sleep(1);
     }
 }
 
-bool AClientConnection::try_enqueue(const ABuffer& buffer)
+bool ClientConnection::try_enqueue(const Buffer& buffer)
 {
-    const_cast<ABuffer&>(buffer).shared_buffer().share_with(server_pid());
+    const_cast<Buffer&>(buffer).shared_buffer().share_with(server_pid());
     auto response = send_sync<AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
     return response->success();
 }
 
-bool AClientConnection::get_muted()
+bool ClientConnection::get_muted()
 {
     return send_sync<AudioServer::GetMuted>()->muted();
 }
 
-void AClientConnection::set_muted(bool muted)
+void ClientConnection::set_muted(bool muted)
 {
     send_sync<AudioServer::SetMuted>(muted);
 }
 
-int AClientConnection::get_main_mix_volume()
+int ClientConnection::get_main_mix_volume()
 {
     return send_sync<AudioServer::GetMainMixVolume>()->volume();
 }
 
-void AClientConnection::set_main_mix_volume(int volume)
+void ClientConnection::set_main_mix_volume(int volume)
 {
     send_sync<AudioServer::SetMainMixVolume>(volume);
 }
 
-int AClientConnection::get_remaining_samples()
+int ClientConnection::get_remaining_samples()
 {
     return send_sync<AudioServer::GetRemainingSamples>()->remaining_samples();
 }
 
-int AClientConnection::get_played_samples()
+int ClientConnection::get_played_samples()
 {
     return send_sync<AudioServer::GetPlayedSamples>()->played_samples();
 }
 
-void AClientConnection::set_paused(bool paused)
+void ClientConnection::set_paused(bool paused)
 {
     send_sync<AudioServer::SetPaused>(paused);
 }
 
-void AClientConnection::clear_buffer(bool paused)
+void ClientConnection::clear_buffer(bool paused)
 {
     send_sync<AudioServer::ClearBuffer>(paused);
 }
 
-int AClientConnection::get_playing_buffer()
+int ClientConnection::get_playing_buffer()
 {
     return send_sync<AudioServer::GetPlayingBuffer>()->buffer_id();
 }
 
-void AClientConnection::handle(const AudioClient::FinishedPlayingBuffer& message)
+void ClientConnection::handle(const AudioClient::FinishedPlayingBuffer& message)
 {
     if (on_finish_playing_buffer)
         on_finish_playing_buffer(message.buffer_id());
 }
 
-void AClientConnection::handle(const AudioClient::MutedStateChanged& message)
+void ClientConnection::handle(const AudioClient::MutedStateChanged& message)
 {
     if (on_muted_state_change)
         on_muted_state_change(message.muted());
 }
+
+}