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 "qaudiosystem_platform_stream_support_p.h"
#include <QtMultimedia/private/qaudio_qiodevice_support_p.h>
#include <QtMultimedia/private/qaudiohelpers_p.h>
#include <QtCore/qdebug.h>
QT_BEGIN_NAMESPACE
namespace QtMultimediaPrivate {
using namespace std::chrono_literals;
QPlatformAudioIOStream::QPlatformAudioIOStream(QAudioDevice m_audioDevice, QAudioFormat m_format,
std::optional<int> ringbufferSize,
std::optional<NativePeriodFrames> nativePeriodFrames,
float volume)
: m_audioDevice{
std::move(m_audioDevice),
},
m_format{
m_format,
},
m_nativePeriodFrames{
nativePeriodFrames,
},
m_volume{
volume,
}
{
prepareRingbuffer(ringbufferSize);
}
QPlatformAudioIOStream::~QPlatformAudioIOStream()
{
Q_ASSERT(m_stopRequested);
}
void QPlatformAudioIOStream::setVolume(float volume)
{
m_volume.store(volume, std::memory_order_relaxed);
}
void QPlatformAudioIOStream::prepareRingbuffer(std::optional<int> ringbufferSize)
{
using SampleFormat = QAudioFormat::SampleFormat;
// Warning: QAudioSink::setBufferSize is measured in *bytes* not in *frames*
int ringbufferElements = inferRingbufferFrames(ringbufferSize, m_nativePeriodFrames, m_format)
* m_format.channelCount();
switch (m_format.sampleFormat()) {
case SampleFormat::Float:
m_ringbuffer.emplace<QAudioRingBuffer<float>>(ringbufferElements);
break;
case SampleFormat::Int16:
m_ringbuffer.emplace<QAudioRingBuffer<int16_t>>(ringbufferElements);
break;
case SampleFormat::Int32:
m_ringbuffer.emplace<QAudioRingBuffer<int32_t>>(ringbufferElements);
break;
case SampleFormat::UInt8:
m_ringbuffer.emplace<QAudioRingBuffer<uint8_t>>(ringbufferElements);
break;
default:
qCritical() << "invalid sample format";
Q_UNREACHABLE_RETURN();
}
}
void QPlatformAudioIOStream::requestStop()
{
m_stopRequested.store(true, std::memory_order_release);
}
qsizetype
QPlatformAudioIOStream::inferRingbufferFrames(const std::optional<int> &ringbufferSize,
const std::optional<NativePeriodFrames> &nativePeriodFrames,
const QAudioFormat &format)
{
int bytesPerFrame = format.bytesPerFrame();
Q_PRESUME(bytesPerFrame > 0);
return inferRingbufferBytes(ringbufferSize, nativePeriodFrames, format) / bytesPerFrame;
}
qsizetype
QPlatformAudioIOStream::inferRingbufferBytes(const std::optional<int> &ringbufferSize,
const std::optional<NativePeriodFrames> &nativePeriodFrames,
const QAudioFormat &format)
{
// ensure to a sane minimum ringbuffer size of twice the hw buffer size or 32 frames
const int minimumRingbufferFrames = nativePeriodFrames
? qToUnderlying(*nativePeriodFrames) * 2
: 32;
const int minimumRingbufferBytes = format.bytesForFrames(minimumRingbufferFrames);
if (ringbufferSize)
return ringbufferSize >= minimumRingbufferBytes ? *ringbufferSize : minimumRingbufferBytes;
using namespace std::chrono;
static constexpr auto defaultBufferDuration = 250ms;
return format.bytesForDuration(microseconds(defaultBufferDuration).count());
}
int QPlatformAudioIOStream::ringbufferSizeInBytes()
{
return visitRingbuffer([](auto &ringbuffer) {
using SampleType = typename std::decay_t<decltype(ringbuffer)>::ValueType;
return ringbuffer.size() * sizeof(SampleType);
});
}
////////////////////////////////////////////////////////////////////////////////////////////////////
QPlatformAudioSinkStream::QPlatformAudioSinkStream(QAudioDevice audioDevice,
const QAudioFormat &format,
std::optional<int> ringbufferSize,
std::optional<NativePeriodFrames> nativePeriodFrames,
float volume)
: QPlatformAudioIOStream{
std::move(audioDevice), format, ringbufferSize, nativePeriodFrames, volume,
}
{
m_streamIdleDetectionConnection = m_streamIdleDetectionNotifier.callOnActivated([this] {
if (isStopRequested())
return;
bool sinkIsIdle = m_streamIsIdle.load();
if (sinkIsIdle) {
// data has been pushed to the ringbuffer, while the stream is
// still idle, this will change during the next audio callback
bool ringbufferIsEmpty = visitRingbuffer([&](auto &ringbuffer) {
return ringbuffer.free() == ringbuffer.size();
});
sinkIsIdle = ringbufferIsEmpty;
}
updateStreamIdle(sinkIsIdle);
});
}
QPlatformAudioSinkStream::~QPlatformAudioSinkStream() = default;
uint64_t
QPlatformAudioSinkStream::process(QSpan<std::byte> hostBuffer, qsizetype totalNumberOfFrames,
std::optional<NativeSampleFormat> nativeFormat) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
qsizetype totalNumberOfSamples = totalNumberOfFrames * m_format.channelCount();
const float vol = volume();
int samplesConsumedFromRingbuffer = visitRingbuffer([&](auto &ringbuffer) {
return ringbuffer.consume(totalNumberOfSamples, [&](auto ringbufferRange) {
if (nativeFormat) {
// Amount of bytes in output range differ from ringbuffer range
const qsizetype samplesInChunk = ringbufferRange.size();
const qsizetype bytesInChunk = samplesInChunk * bytesPerSample(*nativeFormat);
QSpan<std::byte> outputByteRange = take(hostBuffer, bytesInChunk);
hostBuffer = drop(hostBuffer, bytesInChunk);
convertToNative(as_bytes(ringbufferRange), outputByteRange, vol, *nativeFormat);
} else {
QSpan<std::byte> outputByteRange = take(hostBuffer, ringbufferRange.size_bytes());
hostBuffer = drop(hostBuffer, ringbufferRange.size_bytes());
QAudioHelperInternal::applyVolume(vol, m_format, as_bytes(ringbufferRange),
outputByteRange);
}
});
});
if (m_ringbufferWriterDevice) {
qint64 bytes = samplesConsumedFromRingbuffer * m_format.bytesPerSample();
m_ringbufferWriterDevice->bytesConsumedFromRingbuffer(bytes);
}
if (!isStopRequested()) {
if (notificationThresholdBytes == 0 || bytesFree() > notificationThresholdBytes)
m_ringbufferHasSpace.set();
bool streamIsIdle = m_streamIsIdle.load(std::memory_order_relaxed);
if (streamIsIdle && samplesConsumedFromRingbuffer) {
m_streamIsIdle.store(false);
m_streamIdleDetectionNotifier.set();
} else if (!streamIsIdle && !samplesConsumedFromRingbuffer) {
m_streamIsIdle.store(true);
m_streamIdleDetectionNotifier.set();
}
}
if (!hostBuffer.empty()) {
if (nativeFormat)
QAudioHelperInternal::fillSilence(hostBuffer, *nativeFormat);
else
QAudioHelperInternal::fillSilence(hostBuffer, m_format);
}
uint64_t consumedFrames = samplesConsumedFromRingbuffer / m_format.channelCount();
m_processedFrameCount += consumedFrames;
m_totalFrameCount += totalNumberOfFrames;
return consumedFrames;
}
quint64 QPlatformAudioSinkStream::bytesFree() const
{
return visitRingbuffer([](auto &ringbuffer) {
using SampleType = typename std::decay_t<decltype(ringbuffer)>::ValueType;
return ringbuffer.free() * sizeof(SampleType);
});
}
std::chrono::microseconds QPlatformAudioSinkStream::processedDuration() const
{
return std::chrono::microseconds{
m_processedFrameCount * 1'000'000 / m_format.sampleRate(),
};
}
void QPlatformAudioSinkStream::pullFromQIODevice()
{
withPullIODeviceReentrancyGuard([this] {
pullFromQIODeviceImpl();
});
}
void QPlatformAudioSinkStream::pullFromQIODeviceImpl()
{
Q_ASSERT(thread()->isCurrentThread());
Q_ASSERT(m_device);
Q_ASSERT(m_pullIODeviceReentrancyGuard);
visitRingbuffer([&](auto &ringbuffer) {
int elementsPulled = pullFromQIODeviceToRingbuffer(*m_device, ringbuffer);
if (elementsPulled)
updateStreamIdle(false);
});
}
void QPlatformAudioSinkStream::createQIODeviceConnections(QIODevice *device)
{
// consumed from audio thread
m_ringbufferHasSpaceConnection = m_ringbufferHasSpace.callOnActivated(device, [this] {
pullFromQIODevice();
});
// data has been pushed to device
m_iodeviceHasNewDataConnection =
QObject::connect(device, &QIODevice::readyRead, device, [this] {
withPullIODeviceReentrancyGuard([this] {
pullFromQIODeviceImpl();
updateStreamIdle(false);
});
});
}
void QPlatformAudioSinkStream::disconnectQIODeviceConnections()
{
QObject::disconnect(m_ringbufferHasSpaceConnection);
QObject::disconnect(m_iodeviceHasNewDataConnection);
}
QIODevice *QPlatformAudioSinkStream::createRingbufferWriterDevice()
{
m_ringbufferWriterDevice = visitRingbuffer(
[&](auto &ringbuffer) -> std::unique_ptr<QtPrivate::QIODeviceRingBufferWriterBase> {
using SampleType = typename std::decay_t<decltype(ringbuffer)>::ValueType;
return std::make_unique<QtPrivate::QIODeviceRingBufferWriter<SampleType>>(&ringbuffer);
});
return m_ringbufferWriterDevice.get();
}
void QPlatformAudioSinkStream::setQIODevice(QIODevice *device)
{
m_device = device;
}
void QPlatformAudioSinkStream::setIdleState(bool x)
{
m_streamIsIdle.store(x);
}
void QPlatformAudioSinkStream::stopIdleDetection()
{
QObject::disconnect(m_streamIdleDetectionConnection);
}
QThread *QPlatformAudioSinkStream::thread() const
{
// QPlatformAudioSinkStream is not a QObject, but still has a notion of an application thread
// where it lives on.
return m_streamIdleDetectionNotifier.thread();
}
// we limit alloca calls to 0.5MB. it's good enough for virtually all use cases (i.e. buffers
// of 4092 frames / 32 channels) and well in the reasonable range of available stack memory on linux
// (8MB)
static constexpr qsizetype scratchpadBufferSizeLimit = 512 * 1024;
static_assert(scratchpadBufferSizeLimit > 4092 * 32 * sizeof(float));
void QPlatformAudioSinkStream::convertToNative(QSpan<const std::byte> internal,
QSpan<std::byte> native, float volume,
NativeSampleFormat nativeFormat) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
using namespace QAudioHelperInternal;
if (volume == 1.f) {
convertSampleFormat(internal, toNativeSampleFormat(m_format.sampleFormat()), native,
nativeFormat);
return;
}
withTemporaryBuffer<scratchpadBufferSizeLimit>(internal.size(),
[&](QSpan<std::byte> scratchpadBuffer) {
applyVolume(volume, m_format, internal, scratchpadBuffer);
convertSampleFormat(scratchpadBuffer, toNativeSampleFormat(m_format.sampleFormat()), native,
nativeFormat);
});
}
////////////////////////////////////////////////////////////////////////////////////////////////////
QPlatformAudioSourceStream::QPlatformAudioSourceStream(QAudioDevice audioDevice,
const QAudioFormat &format,
std::optional<int> ringbufferSize,
std::optional<NativePeriodFrames> nativePeriodFrames,
float volume)
: QPlatformAudioIOStream{
std::move(audioDevice), format, ringbufferSize, nativePeriodFrames, volume,
}
{
}
QPlatformAudioSourceStream::~QPlatformAudioSourceStream() = default;
uint64_t QPlatformAudioSourceStream::process(
QSpan<const std::byte> hostBuffer, qsizetype numberOfFrames,
std::optional<NativeSampleFormat> nativeFormat) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
qsizetype remainingNumberOfSamples = numberOfFrames * m_format.channelCount();
const float vol = volume();
using namespace QtMultimediaPrivate;
uint64_t totalSamplesWritten = visitRingbuffer([&](auto &rb) {
using SampleType = typename std::decay_t<decltype(rb)>::ValueType;
// clang-format off
return rb.produceSome([&](QSpan<SampleType> ringbufferRange) {
if (nativeFormat) {
// Amount of bytes in input range differ from ringbuffer range
const qsizetype samplesInChunk = ringbufferRange.size();
const qsizetype bytesInChunk = samplesInChunk * bytesPerSample(*nativeFormat);
QSpan<const std::byte> inputByteRange = take(hostBuffer, bytesInChunk);
hostBuffer = drop(hostBuffer, bytesInChunk);
convertFromNative(inputByteRange, as_writable_bytes(ringbufferRange), vol,
*nativeFormat);
} else {
QSpan<const std::byte> inputByteRange =
take(hostBuffer, ringbufferRange.size_bytes());
hostBuffer = drop(hostBuffer, ringbufferRange.size_bytes());
QAudioHelperInternal::applyVolume(vol, m_format, inputByteRange,
as_writable_bytes(ringbufferRange));
}
return ringbufferRange;
}, remainingNumberOfSamples);
// clang-format on
});
if (totalSamplesWritten)
m_ringbufferHasData.set();
uint64_t framesWritten = totalSamplesWritten / m_format.channelCount();
m_totalNumberOfFramesPushedToRingbuffer += framesWritten;
return framesWritten;
}
void QPlatformAudioSourceStream::pushToIODevice()
{
Q_ASSERT(thread()->isCurrentThread());
qsizetype bytesPushed = visitRingbuffer([&](auto &ringbuffer) {
return QtPrivate::pushToQIODeviceFromRingbuffer(*m_device, ringbuffer);
});
if (bytesPushed)
Q_EMIT m_device->readyRead();
}
bool QPlatformAudioSourceStream::deviceIsRingbufferReader() const
{
return m_device == m_ringbufferReaderDevice.get();
}
void QPlatformAudioSourceStream::finalizeQIODevice(ShutdownPolicy shutdownPolicy)
{
switch (shutdownPolicy) {
case ShutdownPolicy::DiscardRingbuffer:
return;
case ShutdownPolicy::DrainRingbuffer:
if (!deviceIsRingbufferReader())
pushToIODevice();
return;
default:
Q_UNREACHABLE_RETURN();
}
}
void QPlatformAudioSourceStream::emptyRingbuffer()
{
visitRingbuffer([](auto &ringbuffer) {
ringbuffer.consumeAll([](auto &) {
});
});
}
QThread *QPlatformAudioSourceStream::thread() const
{
// QPlatformAudioSourceStream is not a QObject, but still has a notion of an application thread
// where it lives on.
return m_ringbufferHasData.thread();
}
qsizetype QPlatformAudioSourceStream::bytesReady() const
{
return visitRingbuffer([](const auto &ringbuffer) {
return ringbuffer.used() * sizeof(typename std::decay_t<decltype(ringbuffer)>::ValueType);
});
}
std::chrono::microseconds QPlatformAudioSourceStream::processedDuration() const
{
return std::chrono::microseconds{
m_format.durationForFrames(
qint32(m_totalNumberOfFramesPushedToRingbuffer.load(std::memory_order_relaxed))),
};
}
void QPlatformAudioSourceStream::setQIODevice(QIODevice *device)
{
m_device = device;
}
void QPlatformAudioSourceStream::createQIODeviceConnections(QIODevice *device)
{
bool pushToDevice = !deviceIsRingbufferReader();
if (pushToDevice) {
m_ringbufferHasDataConnection = m_ringbufferHasData.callOnActivated(device, [this] {
if (!isStopRequested())
updateStreamIdle(false);
pushToIODevice();
});
} else {
m_ringbufferHasDataConnection = m_ringbufferHasData.callOnActivated(device, [this] {
if (!isStopRequested())
updateStreamIdle(false);
Q_EMIT m_device->readyRead();
});
}
m_ringbufferIsFullConnection = m_ringbufferHasData.callOnActivated(device, [this] {
if (!isStopRequested())
updateStreamIdle(false);
});
}
void QPlatformAudioSourceStream::disconnectQIODeviceConnections()
{
QObject::disconnect(m_ringbufferHasDataConnection);
QObject::disconnect(m_ringbufferIsFullConnection);
}
QIODevice *QPlatformAudioSourceStream::createRingbufferReaderDevice()
{
using namespace QtPrivate;
m_ringbufferReaderDevice = visitRingbuffer([&](auto &rb) -> std::unique_ptr<QIODevice> {
using SampleType = typename std::decay_t<decltype(rb)>::ValueType;
return std::make_unique<QIODeviceRingBufferReader<SampleType>>(&rb);
});
m_ringbufferReaderDevice->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
return m_ringbufferReaderDevice.get();
}
void QPlatformAudioSourceStream::convertFromNative(
QSpan<const std::byte> native, QSpan<std::byte> internal, float volume,
NativeSampleFormat nativeFormat) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
using namespace QAudioHelperInternal;
if (volume == 1.f) {
convertSampleFormat(native, nativeFormat, internal,
QAudioHelperInternal::toNativeSampleFormat(m_format.sampleFormat()));
return;
}
withTemporaryBuffer<scratchpadBufferSizeLimit>(internal.size(),
[&](QSpan<std::byte> scratchpadBuffer) {
convertSampleFormat(native, nativeFormat, scratchpadBuffer,
QAudioHelperInternal::toNativeSampleFormat(m_format.sampleFormat()));
applyVolume(volume, m_format, scratchpadBuffer, internal);
});
}
} // namespace QtMultimediaPrivate
QT_END_NAMESPACE
#ifdef Q_CC_MSVC
# undef alloca
#endif