blob: 47595c458df5a17bc18c80c03d0caf655dfb7b00 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#include "ASClientConnection.h"
#include "ASMixer.h"
#include <LibAudio/ABuffer.h>
#include <LibCore/CEventLoop.h>
#include <SharedBuffer.h>
#include <errno.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
static HashMap<int, RefPtr<ASClientConnection>> s_connections;
ASClientConnection::ASClientConnection(CLocalSocket& client_socket, int client_id, ASMixer& mixer)
: ConnectionNG(*this, client_socket, client_id)
, m_mixer(mixer)
{
s_connections.set(client_id, *this);
}
ASClientConnection::~ASClientConnection()
{
}
void ASClientConnection::die()
{
s_connections.remove(client_id());
}
void ASClientConnection::did_finish_playing_buffer(Badge<ASMixer>, int buffer_id)
{
(void)buffer_id;
//post_message(AudioClient::FinishedPlayingBuffer(buffer_id));
}
OwnPtr<AudioServer::GreetResponse> ASClientConnection::handle(const AudioServer::Greet& message)
{
set_client_pid(message.client_pid());
return make<AudioServer::GreetResponse>(getpid(), client_id());
}
OwnPtr<AudioServer::GetMainMixVolumeResponse> ASClientConnection::handle(const AudioServer::GetMainMixVolume&)
{
return make<AudioServer::GetMainMixVolumeResponse>(m_mixer.main_volume());
}
OwnPtr<AudioServer::SetMainMixVolumeResponse> ASClientConnection::handle(const AudioServer::SetMainMixVolume& message)
{
m_mixer.set_main_volume(message.volume());
return make<AudioServer::SetMainMixVolumeResponse>();
}
OwnPtr<AudioServer::EnqueueBufferResponse> ASClientConnection::handle(const AudioServer::EnqueueBuffer& message)
{
auto shared_buffer = SharedBuffer::create_from_shared_buffer_id(message.buffer_id());
if (!shared_buffer) {
// FIXME: The shared buffer should have been retrieved for us already.
// We don't want to do IPC error checking at this layer.
ASSERT_NOT_REACHED();
}
if (!m_queue)
m_queue = m_mixer.create_queue(*this);
if (m_queue->is_full())
return make<AudioServer::EnqueueBufferResponse>(false);
m_queue->enqueue(ABuffer::create_with_shared_buffer(*shared_buffer, message.sample_count()));
return make<AudioServer::EnqueueBufferResponse>(true);
}
OwnPtr<AudioServer::GetRemainingSamplesResponse> ASClientConnection::handle(const AudioServer::GetRemainingSamples&)
{
int remaining = 0;
if (m_queue)
remaining = m_queue->get_remaining_samples();
return make<AudioServer::GetRemainingSamplesResponse>(remaining);
}
OwnPtr<AudioServer::GetPlayedSamplesResponse> ASClientConnection::handle(const AudioServer::GetPlayedSamples&)
{
int played = 0;
if (m_queue)
played = m_queue->get_played_samples();
return make<AudioServer::GetPlayedSamplesResponse>(played);
}
OwnPtr<AudioServer::SetPausedResponse> ASClientConnection::handle(const AudioServer::SetPaused& message)
{
if (m_queue)
m_queue->set_paused(message.paused());
return make<AudioServer::SetPausedResponse>();
}
OwnPtr<AudioServer::ClearBufferResponse> ASClientConnection::handle(const AudioServer::ClearBuffer& message)
{
if (m_queue)
m_queue->clear(message.paused());
return make<AudioServer::ClearBufferResponse>();
}
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>();
}
|
