Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qpulseaudiosink.cpp
Go to the documentation of this file.
1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qpulseaudiosink_p.h"
5
6#include <QtCore/qdebug.h>
7#include <QtMultimedia/private/qaudiohelpers_p.h>
8#include <QtMultimedia/private/qaudiosystem_platform_stream_support_p.h>
9#include <QtMultimedia/private/qpulseaudio_contextmanager_p.h>
10#include <QtMultimedia/private/qpulsehelpers_p.h>
11
12#include <mutex> // for std::lock_guard
13#include <unistd.h>
14
15QT_BEGIN_NAMESPACE
16
17namespace QPulseAudioInternal {
18
19QPulseAudioSinkStream::QPulseAudioSinkStream(QAudioDevice device, const QAudioFormat &format,
20 std::optional<qsizetype> ringbufferSize, QPulseAudioSink *parent,
21 float volume,
22 std::optional<int32_t> hardwareBufferSize,
23 AudioEndpointRole role)
24 : QPlatformAudioSinkStream{
25 std::move(device), format, ringbufferSize, hardwareBufferSize, volume,
26 },
27 m_parent{
28 parent,
29 }
30{
31 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
32
33 pa_sample_spec spec = QPulseAudioInternal::audioFormatToSampleSpec(format);
34 pa_channel_map channel_map = QPulseAudioInternal::channelMapForAudioFormat(format);
35
36 if (Q_UNLIKELY(qLcPulseAudioOut().isEnabled(QtDebugMsg))) {
37 qCDebug(qLcPulseAudioOut) << "Opening stream with.";
38 qCDebug(qLcPulseAudioOut) << "\tFormat: " << spec.format;
39 qCDebug(qLcPulseAudioOut) << "\tRate: " << spec.rate;
40 qCDebug(qLcPulseAudioOut) << "\tChannels: " << spec.channels;
41 qCDebug(qLcPulseAudioOut) << "\tFrame size: " << pa_frame_size(&spec);
42 }
43
44 const QByteArray streamName =
45 QStringLiteral("QtmPulseStream-%1-%2").arg(::getpid()).arg(quintptr(this)).toUtf8();
46
47 PAProplistHandle propList{
48 pa_proplist_new(),
49 };
50 const char *roleString = [&]() -> const char * {
51 switch (role) {
52 case AudioEndpointRole::MediaPlayback:
53 return "music";
54 case AudioEndpointRole::SoundEffect:
55 return "event";
56 case AudioEndpointRole::Accessibility:
57 return "a11y";
58 case AudioEndpointRole::Other:
59 return nullptr;
60 default:
61 Q_UNREACHABLE_RETURN(nullptr);
62 }
63 }();
64
65 if (roleString)
66 pa_proplist_sets(propList.get(), PA_PROP_MEDIA_ROLE, roleString);
67
68 std::lock_guard engineLock{ *pulseEngine };
69
70 m_stream = PAStreamHandle{
71 pa_stream_new_with_proplist(pulseEngine->context(), streamName.constData(), &spec,
72 &channel_map, propList.get()),
73 PAStreamHandle::HasRef,
74 };
75
76 if (!m_stream) {
77 qWarning() << "Failed to create PulseAudio stream";
78 return;
79 }
80}
81
82QPulseAudioSinkStream::~QPulseAudioSinkStream()
83{
84 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
85 std::lock_guard engineLock{ *pulseEngine };
86 m_stream = {};
87}
88
89bool QPulseAudioSinkStream::start(QIODevice *device)
90{
91 setQIODevice(device);
92 pullFromQIODevice();
93
94 createQIODeviceConnections(device);
95
96 bool streamStarted = startStream(StreamType::Ringbuffer);
97 return streamStarted;
98}
99
100bool QPulseAudioSinkStream::start(AudioCallback &&callback)
101{
102 m_audioCallback = std::move(callback);
103
104 bool streamStarted = startStream(StreamType::Callback);
105 return streamStarted;
106}
107
108QIODevice *QPulseAudioSinkStream::start()
109{
110 QIODevice *device = createRingbufferWriterDevice();
111
112 setIdleState(true);
113 bool started = start(device);
114 if (!started)
115 return nullptr;
116
117 return device;
118}
119
120void QPulseAudioSinkStream::stop(ShutdownPolicy policy)
121{
122 requestStop();
123
124 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
125 std::lock_guard engineLock{ *pulseEngine };
126
127 uninstallCallbacks();
128 // Note: we need to cork to ensure that the stream is stopped immediately
129 auto op = streamCork(m_stream, true);
130 pulseEngine->waitForAsyncOperation(op);
131
132 if (m_audioCallback) {
133 switch (policy) {
134 case ShutdownPolicy::DrainRingbuffer:
135 case ShutdownPolicy::DiscardRingbuffer:
136 break;
137 default:
138 Q_UNREACHABLE_RETURN();
139 }
140 } else {
141 switch (policy) {
142 case ShutdownPolicy::DrainRingbuffer: {
143 bool writeFailed = false;
144
145 visitRingbuffer([&](auto &ringbuffer) {
146 ringbuffer.consumeAll([&](auto region) {
147 if (writeFailed)
148 return;
149
150 QSpan<const std::byte> writeRegion = as_bytes(region);
151 int status =
152 pa_stream_write(m_stream.get(), writeRegion.data(), writeRegion.size(),
153 /*free_cb= */ nullptr, /*offset=*/0, PA_SEEK_RELATIVE);
154 if (status != 0)
155 writeFailed = true;
156 });
157 });
158
159 break;
160 }
161 case ShutdownPolicy::DiscardRingbuffer: {
162 break;
163 }
164 default:
165 Q_UNREACHABLE_RETURN();
166 }
167 }
168 pa_stream_disconnect(m_stream.get());
169}
170
171void QPulseAudioSinkStream::suspend()
172{
173 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
174 std::lock_guard engineLock{ *pulseEngine };
175
176 std::ignore = streamCork(m_stream, true);
177}
178
179void QPulseAudioSinkStream::resume()
180{
181 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
182 std::lock_guard engineLock{ *pulseEngine };
183
184 std::ignore = streamCork(m_stream, false);
185}
186
187bool QPulseAudioSinkStream::open() const
188{
189 return m_stream.isValid();
190}
191
192void QPulseAudioSinkStream::installCallbacks(StreamType streamType)
193{
194 switch (streamType) {
195 case StreamType::Ringbuffer:
196 pa_stream_set_write_callback(m_stream.get(),
197 [](pa_stream *stream, size_t nbytes, void *data) {
198 auto *self = reinterpret_cast<QPulseAudioSinkStream *>(data);
199 Q_ASSERT(stream == self->m_stream.get());
200 self->writeCallbackRingbuffer(nbytes);
201 }, this);
202 break;
203 case StreamType::Callback:
204 pa_stream_set_write_callback(m_stream.get(),
205 [](pa_stream *stream, size_t nbytes, void *data) {
206 auto *self = reinterpret_cast<QPulseAudioSinkStream *>(data);
207 Q_ASSERT(stream == self->m_stream.get());
208 self->writeCallbackAudioCallback(nbytes);
209 }, this);
210 break;
211
212 default:
213 Q_UNREACHABLE_RETURN();
214 }
215}
216
217void QPulseAudioSinkStream::uninstallCallbacks()
218{
219 pa_stream_set_write_callback(m_stream.get(), nullptr, nullptr);
220}
221
222bool QPulseAudioSinkStream::startStream(StreamType streamType)
223{
224 pa_buffer_attr attr{
225 .maxlength = uint32_t(m_format.bytesForFrames(m_hardwareBufferFrames.value_or(1024))),
226 .tlength = uint32_t(-1),
227 .prebuf = uint32_t(-1),
228 .minreq = uint32_t(-1),
229 .fragsize = uint32_t(-1),
230 };
231
232 installCallbacks(streamType);
233
234 constexpr pa_stream_flags flags =
235 pa_stream_flags(PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY);
236
237 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
238 std::lock_guard engineLock{ *pulseEngine };
239
240 int status = pa_stream_connect_playback(m_stream.get(), m_audioDevice.id().data(), &attr, flags,
241 nullptr, nullptr);
242
243 if (status != 0) {
244 qCWarning(qLcPulseAudioOut) << "pa_stream_connect_playback() failed!";
245 m_stream = {};
246 return false;
247 }
248 return true;
249}
250
251void QPulseAudioSinkStream::updateStreamIdle(bool idle)
252{
253 m_parent->updateStreamIdle(idle);
254}
255
256void QPulseAudioSinkStream::writeCallbackRingbuffer(size_t requestedBytes)
257{
258 // ensure round down to number of requested frames
259 uint32_t requestedFrames = m_format.framesForBytes(requestedBytes);
260 size_t nbytes = m_format.bytesForFrames(requestedFrames);
261
262 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
263 Q_ASSERT(pulseEngine->isInMainLoop());
264
265 void *dest = nullptr;
266
267 int status = pa_stream_begin_write(m_stream.get(), &dest, &nbytes);
268 if (status != 0) {
269 qCWarning(qLcPulseAudioOut)
270 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
271
272 QMetaObject::invokeMethod(m_parent, [this] {
273 handleIOError(m_parent);
274 });
275 }
276 QSpan<std::byte> hostBuffer{ reinterpret_cast<std::byte *>(dest), qsizetype(nbytes) };
277
278 const uint64_t consumedFrames = process(hostBuffer, requestedFrames);
279 if (consumedFrames != requestedFrames) {
280 auto remainder = drop(hostBuffer, m_format.bytesForFrames(consumedFrames));
281 std::fill(remainder.begin(), remainder.end(), std::byte{});
282 }
283 status = pa_stream_write(m_stream.get(), hostBuffer.data(), nbytes,
284 /*free_cb= */ nullptr, /*offset=*/0, PA_SEEK_RELATIVE);
285 if (status != 0) {
286 qCWarning(qLcPulseAudioOut)
287 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
288
289 QMetaObject::invokeMethod(m_parent, [this] {
290 handleIOError(m_parent);
291 });
292 }
293}
294
295void QPulseAudioSinkStream::writeCallbackAudioCallback(size_t requestedBytes)
296{
297 // ensure round down to number of requested frames
298 uint32_t requestedFrames = m_format.framesForBytes(requestedBytes);
299 size_t nbytes = m_format.bytesForFrames(requestedFrames);
300
301 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
302 Q_ASSERT(pulseEngine->isInMainLoop());
303
304 void *dest = nullptr;
305
306 int status = pa_stream_begin_write(m_stream.get(), &dest, &nbytes);
307 if (status != 0) {
308 qCWarning(qLcPulseAudioOut)
309 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
310
311 invokeOnAppThread([this] {
312 handleIOError(m_parent);
313 });
314 }
315 QSpan<std::byte> hostBuffer{ reinterpret_cast<std::byte *>(dest), qsizetype(nbytes) };
316 runAudioCallback(*m_audioCallback, hostBuffer, m_format, volume());
317
318 status = pa_stream_write(m_stream.get(), hostBuffer.data(), nbytes,
319 /*free_cb= */ nullptr, /*offset=*/0, PA_SEEK_RELATIVE);
320 if (status != 0) {
321 qCWarning(qLcPulseAudioOut)
322 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
323
324 invokeOnAppThread([this] {
325 handleIOError(m_parent);
326 });
327 }
328}
329
330QPulseAudioSink::QPulseAudioSink(QAudioDevice device, const QAudioFormat &format, QObject *parent)
331 : BaseClass(std::move(device), format, parent)
332{
333}
334
335QPulseAudioSink::~QPulseAudioSink()
336 = default;
337
338bool QPulseAudioSink::validatePulseaudio()
339{
340 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
341 if (!pulseEngine->contextIsGood()) {
342 qWarning() << "Invalid PulseAudio context:" << pulseEngine->getContextState();
343 setError(QtAudio::Error::FatalError);
344 return false;
345 }
346 return true;
347}
348
349void QPulseAudioSink::start(QIODevice *device)
350{
351 if (!validatePulseaudio())
352 return;
353 return BaseClass::start(device);
354}
355
356void QPulseAudioSink::start(AudioCallback &&callback)
357{
358 if (!validatePulseaudio())
359 return;
360 return BaseClass::start(std::forward<AudioCallback>(callback));
361}
362
363QIODevice *QPulseAudioSink::start()
364{
365 if (!validatePulseaudio())
366 return nullptr;
367 return BaseClass::start();
368}
369
370} // namespace QPulseAudioInternal
371
372QT_END_NAMESPACE
QPulseAudioInternal::QPulseAudioSink::QPulseAudioSink
QPulseAudioSink(QAudioDevice, const QAudioFormat &, QObject *parent)
Definition qpulseaudiosink.cpp:330
QPulseAudioInternal::QPulseAudioSink::start
void start(QIODevice *device) override
Definition qpulseaudiosink.cpp:349
QPulseAudioInternal::QPulseAudioSink::start
void start(AudioCallback &&) override
Definition qpulseaudiosink.cpp:356
QPulseAudioInternal::QPulseAudioSinkStream::QPulseAudioSinkStream
QPulseAudioSinkStream(QAudioDevice, const QAudioFormat &format, std::optional< qsizetype > ringbufferSize, QPulseAudioSink *parent, float volume, std::optional< int32_t > hardwareBufferSize, AudioEndpointRole)
Definition qpulseaudiosink.cpp:19