Revision control
Copy as Markdown
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qrtaudioengine_p.h"
#include <QtMultimedia/private/qaudiosystem_p.h>
#include <QtMultimedia/private/qmemory_resource_tlsf_p.h>
#include <QtMultimedia/private/qtmm_rtsan_support_p.h>
#include <QtCore/q20map.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qdebug.h>
#include <QtCore/qmutex.h>
#include <QtCore/qthread.h>
#include <mutex>
#ifdef Q_CC_MINGW
// mingw-13.1 seems to have a false positive when using std::function inside a std::variant
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
#endif
QT_BEGIN_NAMESPACE
namespace QtMultimediaPrivate {
using namespace QtPrivate;
using namespace std::chrono_literals;
static QtAudio::State sinkStateToEngineState(QtAudio::State state)
{
switch (state) {
case QtAudio::ActiveState:
case QtAudio::IdleState:
case QtAudio::SuspendedState:
return QtAudio::ActiveState;
case QtAudio::StoppedState:
return QtAudio::StoppedState;
default:
Q_UNREACHABLE_RETURN(QtAudio::StoppedState);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
QRtAudioEngine::QRtAudioEngine(const QAudioDevice &device, const QAudioFormat &format,
std::optional<AudioEndpointRole> role,
std::optional<NativePeriodFrames> nativePeriodFrames)
: QRtAudioEngine{ MoveToApplicationThread::No, device, format, role, nativePeriodFrames }
{
}
QRtAudioEngine::QRtAudioEngine(MoveToApplicationThread moveToApplicationThread,
const QAudioDevice &device, const QAudioFormat &format,
std::optional<AudioEndpointRole> role,
std::optional<NativePeriodFrames> nativePeriodFrames)
: m_sink{
device,
format,
},
m_rtMemoryPool {
std::make_unique<QTlsfMemoryResource>(poolSize)
}
{
m_notificationEvent.callOnActivated([this] {
runNonRtNotifications();
});
if (moveToApplicationThread == MoveToApplicationThread::Yes && !QThread::isMainThread()) {
QThread *appThread = qApp->thread();
moveToThread(appThread);
m_sink.moveToThread(appThread);
m_notificationEvent.moveToThread(appThread);
m_pendingCommandsTimer.moveToThread(appThread);
}
m_pendingCommandsTimer.setInterval(10ms);
m_pendingCommandsTimer.setTimerType(Qt::CoarseTimer);
m_pendingCommandsTimer.callOnTimeout(&m_pendingCommandsTimer, [this] {
auto lock = std::lock_guard{ m_mutex };
sendPendingRtCommands();
if (m_appToRtOverflowBuffer.empty())
m_pendingCommandsTimer.stop();
});
QPlatformAudioSink *platformSink = QPlatformAudioSink::get(m_sink);
if (role)
platformSink->setRole(*role);
if (nativePeriodFrames)
platformSink->setNativePeriodFrames(*nativePeriodFrames);
m_sink.start([this](QSpan<float> outputBuffer) {
audioCallback(outputBuffer);
});
// we start suspended
m_sink.suspend();
QObject::connect(&m_sink, &QAudioSink::stateChanged, this, [&](QtAudio::State state) {
Q_EMIT stateChanged(sinkStateToEngineState(state));
});
}
QRtAudioEngine::~QRtAudioEngine()
{
m_sink.reset();
// consume the ringbuffers
m_appToRt.consumeAll([](auto) {
});
m_rtToApp.consumeAll([](auto) {
});
}
void QRtAudioEngine::play(SharedVoice voice)
{
auto lock = std::lock_guard{ m_mutex };
// TODO: where do we expect reampling to happen?
Q_ASSERT(voice->format() == m_sink.format());
if (m_voices.empty())
m_sink.resume();
m_voices.insert(voice);
sendAppToRtCommand(PlayCommand{
std::move(voice),
});
}
void QRtAudioEngine::stop(const SharedVoice &voice)
{
stop(voice->voiceId());
}
void QRtAudioEngine::stop(VoiceId voiceId)
{
auto lock = std::lock_guard{ m_mutex };
sendAppToRtCommand(StopCommand{ voiceId });
}
void QRtAudioEngine::visitVoiceRt(VoiceId voiceId, RtVoiceVisitor fn, bool visitorIsTrivial)
{
auto lock = std::lock_guard{ m_mutex };
if (visitorIsTrivial) {
sendAppToRtCommand(VisitCommandTrivial{
voiceId,
std::move(fn),
});
} else {
sendAppToRtCommand(VisitCommand{
voiceId,
std::move(fn),
});
}
}
VoiceId QRtAudioEngine::allocateVoiceId()
{
static std::atomic_uint64_t allocator{ 0 };
return VoiceId{ allocator.fetch_add(1, std::memory_order_relaxed) };
}
QtAudio::State QRtAudioEngine::audioState() const
{
return sinkStateToEngineState(m_sink.state());
}
void QRtAudioEngine::audioCallback(QSpan<float> outputBuffer) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
runRtCommands();
bool sendNotification = sendPendingAppNotifications();
std::fill(outputBuffer.begin(), outputBuffer.end(), 0.f);
std::vector<SharedVoice, pmr::polymorphic_allocator<SharedVoice>> finishedVoices{
m_rtMemoryPool.get(),
};
for (const SharedVoice &voice : m_rtVoiceRegistry) {
Q_ASSERT(voice.use_count() >= 2); // voice in both m_rtVoiceRegistry and m_voices
VoicePlayResult playResult = voice->play(outputBuffer);
if (playResult == VoicePlayResult::Finished)
finishedVoices.push_back(voice);
}
if (!finishedVoices.empty()) {
withRTSanDisabled([&] {
for (const SharedVoice &voice : finishedVoices) {
m_rtVoiceRegistry.erase(voice);
bool stopSent = sendRtToAppNotification(StopNotification{ voice });
if (stopSent)
sendNotification = true;
}
});
}
// TODO: we should probably (soft)clip the output buffer
cleanupRetiredVoices();
if (sendNotification)
m_notificationEvent.set();
}
void QRtAudioEngine::cleanupRetiredVoices() noexcept Q_DECL_NONBLOCKING_FUNCTION
{
bool notifyApp = false;
#if __cpp_lib_erase_if >= 202002L
using std::erase_if;
#else
auto erase_if = [](auto &c, auto &&pred) {
auto old_size = c.size();
for (auto first = c.begin(), last = c.end(); first != last;) {
if (pred(*first))
first = c.erase(first);
else
++first;
}
return old_size - c.size();
};
#endif
withRTSanDisabled([&] {
erase_if(m_rtVoiceRegistry, [&](const SharedVoice &voice) {
bool voiceIsActive = voice->isActive();
if (!voiceIsActive)
notifyApp = sendRtToAppNotification(StopNotification{ voice });
return !voiceIsActive;
});
});
if (notifyApp)
m_notificationEvent.set();
}
void QRtAudioEngine::runRtCommands() noexcept Q_DECL_NONBLOCKING_FUNCTION
{
m_appToRt.consumeAll([&](QSpan<RtCommand> commands) {
for (RtCommand &cmd : commands) {
std::visit([&](auto cmd) {
runRtCommand(std::move(cmd));
}, std::move(cmd));
}
});
}
void QRtAudioEngine::runRtCommand(PlayCommand cmd) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
withRTSanDisabled([&] {
m_rtVoiceRegistry.insert(cmd.voice);
});
}
void QRtAudioEngine::runRtCommand(StopCommand cmd) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
auto it = m_rtVoiceRegistry.find(cmd.voiceId);
if (it == m_rtVoiceRegistry.end())
return;
SharedVoice voice = *it;
m_rtVoiceRegistry.erase(it);
bool emitNotify = sendRtToAppNotification(StopNotification{
std::move(voice),
});
if (emitNotify)
m_notificationEvent.set();
}
void QRtAudioEngine::runRtCommand(VisitCommand cmd) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
auto it = m_rtVoiceRegistry.find(cmd.voiceId);
if (it == m_rtVoiceRegistry.end())
return;
cmd.callback(**it);
// send callback back to application for destruction
bool emitNotify = sendRtToAppNotification(VisitReply{
std::move(cmd.callback),
});
if (emitNotify)
m_notificationEvent.set();
}
void QRtAudioEngine::runRtCommand(VisitCommandTrivial cmd) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
auto it = m_rtVoiceRegistry.find(cmd.voiceId);
if (it == m_rtVoiceRegistry.end())
return;
cmd.callback(**it);
}
void QRtAudioEngine::runNonRtNotifications()
{
std::vector<VoiceId> finishedVoices;
{
auto lock = std::lock_guard{ m_mutex };
m_rtToApp.consumeAll([&](QSpan<Notification> notifications) {
for (Notification ¬ification : notifications) {
std::visit([&](auto notification) {
runNonRtNotification(std::move(notification));
}, std::move(notification));
}
});
finishedVoices = std::move(m_finishedVoices);
m_finishedVoices.clear();
}
// emit voiceFinished outside of the lock
for (VoiceId voiceId : finishedVoices)
Q_EMIT voiceFinished(voiceId);
}
void QRtAudioEngine::runNonRtNotification(StopNotification notification)
{
m_voices.erase(notification.voice);
if (m_voices.empty())
m_sink.suspend();
m_finishedVoices.push_back(notification.voice->voiceId());
}
void QRtAudioEngine::runNonRtNotification(VisitReply)
{
// nop (just making sure to delete on the application thread);
}
void QRtAudioEngine::sendAppToRtCommand(RtCommand cmd)
{
// first write all pending commands from overflow buffer
sendPendingRtCommands();
bool written = m_appToRt.produceOne([&] {
return std::move(cmd);
});
if (written)
return;
m_appToRtOverflowBuffer.emplace_back(std::move(cmd));
QMetaObject::invokeMethod(&m_pendingCommandsTimer, [this] {
if (!m_pendingCommandsTimer.isActive())
m_pendingCommandsTimer.start();
});
}
bool QRtAudioEngine::sendRtToAppNotification(Notification cmd)
{
// first write all pending commands from overflow buffer
bool emitNotification = sendPendingAppNotifications();
bool written = m_rtToApp.produceOne([&] {
return std::move(cmd);
});
if (written)
return true;
m_rtToAppOverflowBuffer.emplace_back(std::move(cmd));
return emitNotification;
}
void QRtAudioEngine::sendPendingRtCommands()
{
while (!m_appToRtOverflowBuffer.empty()) {
Q_UNLIKELY_BRANCH;
bool written = m_appToRt.produceOne([&] {
return std::move(m_appToRtOverflowBuffer.front());
});
if (!written)
return;
m_appToRtOverflowBuffer.pop_front();
}
}
bool QRtAudioEngine::sendPendingAppNotifications()
{
bool emitNotification = false;
while (!m_rtToAppOverflowBuffer.empty()) {
Q_UNLIKELY_BRANCH;
// first write all pending commands from overflow buffer
bool written = m_rtToApp.produceOne([&] {
return std::move(m_rtToAppOverflowBuffer.front());
});
if (!written)
break;
m_rtToAppOverflowBuffer.pop_front();
emitNotification = true;
}
return emitNotification;
}
} // namespace QtMultimediaPrivate
QT_END_NAMESPACE
#ifdef Q_CC_MINGW
QT_WARNING_POP
#endif
#include "moc_qrtaudioengine_p.cpp"