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 const auto id = m_audioDevice.id();
241 int status = pa_stream_connect_playback(m_stream.get(), id.data(), &attr, flags,
242 nullptr, nullptr);
243
244 if (status != 0) {
245 qCWarning(qLcPulseAudioOut) << "pa_stream_connect_playback() failed!";
246 m_stream = {};
247 return false;
248 }
249 return true;
250}
251
252void QPulseAudioSinkStream::updateStreamIdle(bool idle)
253{
254 m_parent->updateStreamIdle(idle);
255}
256
257void QPulseAudioSinkStream::writeCallbackRingbuffer(size_t requestedBytes)
258{
259 // ensure round down to number of requested frames
260 uint32_t requestedFrames = m_format.framesForBytes(requestedBytes);
261 size_t nbytes = m_format.bytesForFrames(requestedFrames);
262
263 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
264 Q_ASSERT(pulseEngine->isInMainLoop());
265
266 void *dest = nullptr;
267
268 int status = pa_stream_begin_write(m_stream.get(), &dest, &nbytes);
269 if (status != 0) {
270 qCWarning(qLcPulseAudioOut)
271 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
272
273 QMetaObject::invokeMethod(m_parent, [this] {
274 handleIOError(m_parent);
275 });
276 }
277 QSpan<std::byte> hostBuffer{ reinterpret_cast<std::byte *>(dest), qsizetype(nbytes) };
278
279 const uint64_t consumedFrames = process(hostBuffer, requestedFrames);
280 if (consumedFrames != requestedFrames) {
281 auto remainder = drop(hostBuffer, m_format.bytesForFrames(consumedFrames));
282 std::fill(remainder.begin(), remainder.end(), std::byte{});
283 }
284 status = pa_stream_write(m_stream.get(), hostBuffer.data(), nbytes,
285 /*free_cb= */ nullptr, /*offset=*/0, PA_SEEK_RELATIVE);
286 if (status != 0) {
287 qCWarning(qLcPulseAudioOut)
288 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
289
290 QMetaObject::invokeMethod(m_parent, [this] {
291 handleIOError(m_parent);
292 });
293 }
294}
295
296void QPulseAudioSinkStream::writeCallbackAudioCallback(size_t requestedBytes)
297{
298 // ensure round down to number of requested frames
299 uint32_t requestedFrames = m_format.framesForBytes(requestedBytes);
300 size_t nbytes = m_format.bytesForFrames(requestedFrames);
301
302 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
303 Q_ASSERT(pulseEngine->isInMainLoop());
304
305 void *dest = nullptr;
306
307 int status = pa_stream_begin_write(m_stream.get(), &dest, &nbytes);
308 if (status != 0) {
309 qCWarning(qLcPulseAudioOut)
310 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
311
312 invokeOnAppThread([this] {
313 handleIOError(m_parent);
314 });
315 }
316 QSpan<std::byte> hostBuffer{ reinterpret_cast<std::byte *>(dest), qsizetype(nbytes) };
317 runAudioCallback(*m_audioCallback, hostBuffer, m_format, volume());
318
319 status = pa_stream_write(m_stream.get(), hostBuffer.data(), nbytes,
320 /*free_cb= */ nullptr, /*offset=*/0, PA_SEEK_RELATIVE);
321 if (status != 0) {
322 qCWarning(qLcPulseAudioOut)
323 << "pa_stream_begin_write error:" << currentError(pulseEngine->context());
324
325 invokeOnAppThread([this] {
326 handleIOError(m_parent);
327 });
328 }
329}
330
331QPulseAudioSink::QPulseAudioSink(QAudioDevice device, const QAudioFormat &format, QObject *parent)
332 : BaseClass(std::move(device), format, parent)
333{
334}
335
336QPulseAudioSink::~QPulseAudioSink()
337 = default;
338
339bool QPulseAudioSink::validatePulseaudio()
340{
341 QPulseAudioContextManager *pulseEngine = QPulseAudioContextManager::instance();
342 if (!pulseEngine->contextIsGood()) {
343 qWarning() << "Invalid PulseAudio context:" << pulseEngine->getContextState();
344 setError(QtAudio::Error::FatalError);
345 return false;
346 }
347 return true;
348}
349
350void QPulseAudioSink::start(QIODevice *device)
351{
352 if (!validatePulseaudio())
353 return;
354 return BaseClass::start(device);
355}
356
357void QPulseAudioSink::start(AudioCallback &&callback)
358{
359 if (!validatePulseaudio())
360 return;
361 return BaseClass::start(std::forward<AudioCallback>(callback));
362}
363
364QIODevice *QPulseAudioSink::start()
365{
366 if (!validatePulseaudio())
367 return nullptr;
368 return BaseClass::start();
369}
370
371} // namespace QPulseAudioInternal
372
373QT_END_NAMESPACE
QPulseAudioInternal::QPulseAudioSink::QPulseAudioSink
QPulseAudioSink(QAudioDevice, const QAudioFormat &, QObject *parent)
Definition qpulseaudiosink.cpp:331
QPulseAudioInternal::QPulseAudioSink::start
void start(QIODevice *device) override
Definition qpulseaudiosink.cpp:350
QPulseAudioInternal::QPulseAudioSink::start
void start(AudioCallback &&) override
Definition qpulseaudiosink.cpp:357
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