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