mirror of
https://github.com/RGBCube/serenity
synced 2025-05-26 01:55:08 +00:00
96d02a3e75
Previously, a libc-like out-of-line error information was used in the loader and its plugins. Now, all functions that may fail to do their job return some sort of Result. The universally-used error type ist the new LoaderError, which can contain information about the general error category (such as file format, I/O, unimplemented features), an error description, and location information, such as file index or sample index. Additionally, the loader plugins try to do as little work as possible in their constructors. Right after being constructed, a user should call initialize() and check the errors returned from there. (This is done transparently by Loader itself.) If a constructor caused an error, the call to initialize should check and return it immediately. This opportunity was used to rework a lot of the internal error propagation in both loader classes, especially FlacLoader. Therefore, a couple of other refactorings may have sneaked in as well. The adoption of LibAudio users is minimal. Piano's adoption is not important, as the code will receive major refactoring in the near future anyways. SoundPlayer's adoption is also less important, as changes to refactor it are in the works as well. aplay's adoption is the best and may serve as an example for other users. It also includes new buffering behavior. Buffer also gets some attention, making it OOM-safe and thereby also propagating its errors to the user.
152 lines
3.6 KiB
C++
152 lines
3.6 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "ClientConnection.h"
|
|
#include "Mixer.h"
|
|
#include <AudioServer/AudioClientEndpoint.h>
|
|
#include <LibAudio/Buffer.h>
|
|
|
|
namespace AudioServer {
|
|
|
|
static HashMap<int, RefPtr<ClientConnection>> s_connections;
|
|
|
|
void ClientConnection::for_each(Function<void(ClientConnection&)> callback)
|
|
{
|
|
NonnullRefPtrVector<ClientConnection> connections;
|
|
for (auto& it : s_connections)
|
|
connections.append(*it.value);
|
|
for (auto& connection : connections)
|
|
callback(connection);
|
|
}
|
|
|
|
ClientConnection::ClientConnection(NonnullRefPtr<Core::LocalSocket> client_socket, int client_id, Mixer& mixer)
|
|
: IPC::ClientConnection<AudioClientEndpoint, AudioServerEndpoint>(*this, move(client_socket), client_id)
|
|
, m_mixer(mixer)
|
|
{
|
|
s_connections.set(client_id, *this);
|
|
}
|
|
|
|
ClientConnection::~ClientConnection()
|
|
{
|
|
}
|
|
|
|
void ClientConnection::die()
|
|
{
|
|
s_connections.remove(client_id());
|
|
}
|
|
|
|
void ClientConnection::did_finish_playing_buffer(Badge<ClientAudioStream>, int buffer_id)
|
|
{
|
|
async_finished_playing_buffer(buffer_id);
|
|
}
|
|
|
|
void ClientConnection::did_change_muted_state(Badge<Mixer>, bool muted)
|
|
{
|
|
async_muted_state_changed(muted);
|
|
}
|
|
|
|
void ClientConnection::did_change_main_mix_volume(Badge<Mixer>, double volume)
|
|
{
|
|
async_main_mix_volume_changed(volume);
|
|
}
|
|
|
|
void ClientConnection::did_change_client_volume(Badge<ClientAudioStream>, double volume)
|
|
{
|
|
async_client_volume_changed(volume);
|
|
}
|
|
|
|
Messages::AudioServer::GetMainMixVolumeResponse ClientConnection::get_main_mix_volume()
|
|
{
|
|
return m_mixer.main_volume();
|
|
}
|
|
|
|
void ClientConnection::set_main_mix_volume(double volume)
|
|
{
|
|
m_mixer.set_main_volume(volume);
|
|
}
|
|
|
|
Messages::AudioServer::GetSampleRateResponse ClientConnection::get_sample_rate()
|
|
{
|
|
return { m_mixer.audiodevice_get_sample_rate() };
|
|
}
|
|
|
|
void ClientConnection::set_sample_rate(u32 sample_rate)
|
|
{
|
|
m_mixer.audiodevice_set_sample_rate(sample_rate);
|
|
}
|
|
|
|
Messages::AudioServer::GetSelfVolumeResponse ClientConnection::get_self_volume()
|
|
{
|
|
return m_queue->volume().target();
|
|
}
|
|
|
|
void ClientConnection::set_self_volume(double volume)
|
|
{
|
|
if (m_queue)
|
|
m_queue->set_volume(volume);
|
|
}
|
|
|
|
Messages::AudioServer::EnqueueBufferResponse ClientConnection::enqueue_buffer(Core::AnonymousBuffer const& buffer, i32 buffer_id, int sample_count)
|
|
{
|
|
if (!m_queue)
|
|
m_queue = m_mixer.create_queue(*this);
|
|
|
|
if (m_queue->is_full())
|
|
return false;
|
|
|
|
// There's not a big allocation to worry about here.
|
|
m_queue->enqueue(MUST(Audio::Buffer::create_with_anonymous_buffer(buffer, buffer_id, sample_count)));
|
|
return true;
|
|
}
|
|
|
|
Messages::AudioServer::GetRemainingSamplesResponse ClientConnection::get_remaining_samples()
|
|
{
|
|
int remaining = 0;
|
|
if (m_queue)
|
|
remaining = m_queue->get_remaining_samples();
|
|
|
|
return remaining;
|
|
}
|
|
|
|
Messages::AudioServer::GetPlayedSamplesResponse ClientConnection::get_played_samples()
|
|
{
|
|
int played = 0;
|
|
if (m_queue)
|
|
played = m_queue->get_played_samples();
|
|
|
|
return played;
|
|
}
|
|
|
|
void ClientConnection::set_paused(bool paused)
|
|
{
|
|
if (m_queue)
|
|
m_queue->set_paused(paused);
|
|
}
|
|
|
|
void ClientConnection::clear_buffer(bool paused)
|
|
{
|
|
if (m_queue)
|
|
m_queue->clear(paused);
|
|
}
|
|
|
|
Messages::AudioServer::GetPlayingBufferResponse ClientConnection::get_playing_buffer()
|
|
{
|
|
int id = -1;
|
|
if (m_queue)
|
|
id = m_queue->get_playing_buffer();
|
|
return id;
|
|
}
|
|
|
|
Messages::AudioServer::GetMutedResponse ClientConnection::get_muted()
|
|
{
|
|
return m_mixer.is_muted();
|
|
}
|
|
|
|
void ClientConnection::set_muted(bool muted)
|
|
{
|
|
m_mixer.set_muted(muted);
|
|
}
|
|
}
|