mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-05-10 13:12:56 +00:00
b4fbd30b70
This change was a long time in the making ever since we obtained sample rate awareness in the system. Now, each client has its own sample rate, accessible via new IPC APIs, and the device sample rate is only accessible via the management interface. AudioServer takes care of resampling client streams into the device sample rate. Therefore, the main improvement introduced with this commit is full responsiveness to sample rate changes; all open audio programs will continue to play at correct speed with the audio resampled to the new device rate. The immediate benefits are manifold: - Gets rid of the legacy hardware sample rate IPC message in the non-managing client - Removes duplicate resampling and sample index rescaling code everywhere - Avoids potential sample index scaling bugs in SoundPlayer (which have happened many times before) and fixes a sample index scaling bug in aplay - Removes several FIXMEs - Reduces amount of sample copying in all applications (especially Piano, where this is critical), improving performance - Reduces number of resampling users, making future API changes (which will need to happen for correct resampling to be implemented) easier I also threw in a simple race condition fix for Piano's audio player loop.
90 lines
3.3 KiB
C++
90 lines
3.3 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2022, kleines Filmröllchen <filmroellchen@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Concepts.h>
|
|
#include <AK/FixedArray.h>
|
|
#include <AK/NonnullOwnPtr.h>
|
|
#include <AK/OwnPtr.h>
|
|
#include <LibAudio/Queue.h>
|
|
#include <LibAudio/UserSampleQueue.h>
|
|
#include <LibCore/EventLoop.h>
|
|
#include <LibCore/Object.h>
|
|
#include <LibIPC/ConnectionToServer.h>
|
|
#include <LibThreading/Mutex.h>
|
|
#include <LibThreading/Thread.h>
|
|
#include <Userland/Services/AudioServer/AudioClientEndpoint.h>
|
|
#include <Userland/Services/AudioServer/AudioServerEndpoint.h>
|
|
|
|
namespace Audio {
|
|
|
|
class ConnectionToServer final
|
|
: public IPC::ConnectionToServer<AudioClientEndpoint, AudioServerEndpoint>
|
|
, public AudioClientEndpoint {
|
|
IPC_CLIENT_CONNECTION(ConnectionToServer, "/tmp/session/%sid/portal/audio"sv)
|
|
public:
|
|
virtual ~ConnectionToServer() override;
|
|
|
|
// Both of these APIs are for convenience and when you don't care about real-time behavior.
|
|
// They will not work properly in conjunction with realtime_enqueue.
|
|
// If you don't refill the buffer in time with this API, the last shared buffer write is zero-padded to play all of the samples.
|
|
template<ArrayLike<Sample> Samples>
|
|
ErrorOr<void> async_enqueue(Samples&& samples)
|
|
{
|
|
return async_enqueue(TRY(FixedArray<Sample>::create(samples.span())));
|
|
}
|
|
|
|
ErrorOr<void> async_enqueue(FixedArray<Sample>&& samples);
|
|
|
|
void clear_client_buffer();
|
|
|
|
// Returns immediately with the appropriate status if the buffer is full; use in conjunction with remaining_buffers to get low latency.
|
|
ErrorOr<void, AudioQueue::QueueStatus> realtime_enqueue(Array<Sample, AUDIO_BUFFER_SIZE> samples);
|
|
ErrorOr<void> blocking_realtime_enqueue(Array<Sample, AUDIO_BUFFER_SIZE> samples, Function<void()> wait_function);
|
|
|
|
// This information can be deducted from the shared audio buffer.
|
|
unsigned total_played_samples() const;
|
|
// How many samples remain in m_enqueued_samples.
|
|
unsigned remaining_samples();
|
|
// How many buffers (i.e. short sample arrays) the server hasn't played yet.
|
|
// Non-realtime code needn't worry about this.
|
|
size_t remaining_buffers() const;
|
|
|
|
void set_self_sample_rate(u32 sample_rate);
|
|
|
|
virtual void die() override;
|
|
|
|
Function<void(double volume)> on_client_volume_change;
|
|
|
|
private:
|
|
ConnectionToServer(NonnullOwnPtr<Core::LocalSocket>);
|
|
|
|
virtual void client_volume_changed(double) override;
|
|
|
|
// We use this to perform the audio enqueuing on the background thread's event loop
|
|
virtual void custom_event(Core::CustomEvent&) override;
|
|
|
|
void update_good_sleep_time();
|
|
|
|
// Shared audio buffer: both server and client constantly read and write to/from this.
|
|
// This needn't be mutex protected: it's internally multi-threading aware.
|
|
OwnPtr<AudioQueue> m_buffer;
|
|
|
|
// The queue of non-realtime audio provided by the user.
|
|
NonnullOwnPtr<UserSampleQueue> m_user_queue;
|
|
|
|
NonnullRefPtr<Threading::Thread> m_background_audio_enqueuer;
|
|
Core::EventLoop* m_enqueuer_loop { nullptr };
|
|
Threading::Mutex m_enqueuer_loop_destruction;
|
|
|
|
// A good amount of time to sleep when the queue is full.
|
|
// (Only used for non-realtime enqueues)
|
|
timespec m_good_sleep_time {};
|
|
};
|
|
|
|
}
|