Revision control
Copy as Markdown
// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-3.0-only
#include "qspatialaudiosound_p.h"
#include <QtSpatialAudio/private/qaudioengine_p.h>
#include <QtMultimedia/qaudiosink.h>
#include <QtMultimedia/private/qaudio_qspan_support_p.h>
#include <QtMultimedia/private/qaudiohelpers_p.h>
#include <QtMultimedia/private/qmultimedia_ranges_p.h>
#include <QtMultimedia/private/qmultimediautils_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/qurl.h>
#include <resonance_audio.h>
#include <memory>
QT_BEGIN_NAMESPACE
namespace QSpatialAudioPrivate {
constexpr int InfiniteLoops = -1;
QSpatialAudioPlaybackState::QSpatialAudioPlaybackState(QAudioBuffer buffer, bool playing, int loops)
: m_playing(playing), m_loops(loops), m_buffer(std::move(buffer))
{
}
void QSpatialAudioPlaybackState::getBuffer(QSpan<float> output)
{
using QtMultimediaPrivate::drop;
using QtMultimediaPrivate::take;
namespace ranges = QtMultimediaPrivate::ranges;
if (!m_playing.load(std::memory_order_relaxed)) {
ranges::fill(output, 0.f);
return;
}
QSpan<const float> wholeSampleBuffer{
m_buffer.constData<float>(),
m_buffer.sampleCount(),
};
while (!output.empty()) {
QSpan remainingSamples = drop(wholeSampleBuffer, m_currentSample);
const QSpan samplesToCopy = take(remainingSamples, output.size());
ranges::copy(samplesToCopy, output.begin());
output = drop(output, samplesToCopy.size());
m_currentSample += samplesToCopy.size();
if (output.empty())
return;
// Reached end of buffer
Q_ASSERT(m_currentSample == wholeSampleBuffer.size());
m_currentSample = 0;
switch (m_loops) {
case InfiniteLoops:
break; // Continue looping
case 0:
m_playing = false;
m_currentLoop = 0;
ranges::fill(output, 0.f);
return;
default:
++m_currentLoop;
if (m_currentLoop >= m_loops) {
m_playing = false;
m_currentLoop = 0;
ranges::fill(output, 0.f);
return;
}
break;
}
}
}
void QSpatialAudioPlaybackState::resume()
{
m_playing = true;
}
void QSpatialAudioPlaybackState::setLoops(int loops)
{
m_loops = loops;
}
QAudioFormat QSpatialAudioPlaybackState::format() const
{
return m_buffer.format();
}
void QSpatialAudioPlaybackState::pause()
{
m_playing = false;
}
} // namespace QSpatialAudioPrivate
QSpatialAudioSoundPrivate::QSpatialAudioSoundPrivate(QAudioEngine *engine, int nchannels, int sourceId)
: nchannels(nchannels), engine(engine), sourceId(sourceId)
{
auto *ep = QAudioEnginePrivate::get(engine);
if (!ep)
return;
ep->addSound(this);
}
QSpatialAudioSoundPrivate::~QSpatialAudioSoundPrivate()
{
auto *ep = QAudioEnginePrivate::get(engine);
if (ep)
ep->removeSound(this);
withResonanceApi([&](vraudio::ResonanceAudioApi *api) {
api->DestroySource(sourceId);
});
}
void QSpatialAudioSoundPrivate::setVolume(float volume)
{
m_volume = volume;
applyVolume();
}
void QSpatialAudioSoundPrivate::setLoops(int loops)
{
m_loops = loops;
if (m_playbackState)
m_playbackState->setLoops(loops);
}
void QSpatialAudioSoundPrivate::setAutoPlay(bool enabled)
{
m_autoPlay = enabled;
}
void QSpatialAudioSoundPrivate::applyVolume()
{
withResonanceApi([&](vraudio::ResonanceAudioApi *api) {
api->SetSourceVolume(sourceId, m_volume);
});
}
void QSpatialAudioSoundPrivate::play()
{
qCDebug(qLcSpatialAudioEngine) << "Playing sound";
switch (m_state) {
case State::Stopped: {
m_state = State::Playing;
if (m_buffer) {
setState(std::make_shared<QSpatialAudioPlaybackState>(*m_buffer, /*playing=*/true,
m_loops));
}
return;
}
case State::Paused:
case State::Playing: {
m_state = State::Playing;
if (m_playbackState)
m_playbackState->resume();
return;
}
}
}
void QSpatialAudioSoundPrivate::pause()
{
qCDebug(qLcSpatialAudioEngine) << "Pausing sound";
switch (m_state) {
case State::Stopped: {
m_state = State::Paused;
setState(std::make_shared<QSpatialAudioPlaybackState>(*m_buffer, /*playing=*/false,
m_loops));
return;
}
case State::Paused: {
return;
}
case State::Playing: {
m_state = State::Paused;
setState(nullptr);
if (m_playbackState)
m_playbackState->pause();
return;
}
}
}
void QSpatialAudioSoundPrivate::stop()
{
qCDebug(qLcSpatialAudioEngine) << "Stopping sound";
switch (m_state) {
case State::Stopped: {
return;
}
case State::Paused:
case State::Playing: {
m_state = State::Stopped;
setState({});
return;
}
}
}
void QSpatialAudioSoundPrivate::loadUrl(const QUrl &url)
{
qCDebug(qLcSpatialAudioEngine) << "Loading sound:" << url;
m_url = url;
auto *ep = QAudioEnginePrivate::get(engine);
if (!ep)
return;
m_loadFuture.cancelChain();
m_sample = {};
setState(nullptr);
m_loadFuture = QSampleCache::instance()
->requestSampleFuture(m_sourceResolver->resolve(url), ep->sampleRate())
.then(q_ptr, [this](SharedSamplePtr sample) {
if (!sample) {
qCWarning(qLcSpatialAudioEngine) << "QAmbientSound: cannot load file";
return;
}
// Build QAudioBuffer with the correct channel layout for this source.
// QSampleCache resampled to engineRate but preserves native channels.
// Adapt channel count here: mono<->stereo simple mix.
const QAudioFormat &srcFmt = sample->format();
const int srcChannels = srcFmt.channelCount();
QByteArray pcmData;
QAudioFormat outFmt = srcFmt;
outFmt.setChannelCount(nchannels);
outFmt.setChannelConfig(nchannels == 2 ? QAudioFormat::ChannelConfigStereo
: QAudioFormat::ChannelConfigMono);
using namespace QAudioHelperInternal;
if (srcChannels == nchannels) {
pcmData = sample->data();
m_sample = std::move(sample); // keep the sample in the QSampleCache as long as we live
} else if (srcChannels == 1 && nchannels == 2) {
qWarning() << "QAmbientSound: upmixing mono source to stereo";
pcmData = upmixMonoToStereo(sample->dataAsFloatSpan(), UpmixScaling::Duplicate);
} else if (srcChannels == 2 && nchannels == 1) {
qWarning() << "QAmbientSound: downmixing stereo source to mono";
pcmData = downmixStereoToMono(sample->dataAsFloatSpan(), DownmixScaling::Average);
} else {
qWarning() << "QAmbientSound: unsupported channel count"
<< srcChannels << "- rejecting file";
return;
}
m_buffer = QAudioBuffer{
pcmData,
outFmt,
};
qCDebug(qLcSpatialAudioEngine) << "Sound loaded";
const bool startingPlayback = m_autoPlay || m_state != State::Stopped;
if (!startingPlayback)
return;
const bool startPaused = (m_state == State::Paused) && !m_autoPlay;
setState(std::make_shared<QSpatialAudioPlaybackState>(*m_buffer, /*playing=*/!startPaused,
m_loops));
m_state = startPaused ? State::Paused : State::Playing;
qCDebug(qLcSpatialAudioEngine)
<< "Sound playback started:" << (startPaused ? "paused" : "playing");
});
}
vraudio::ResonanceAudioApi *QSpatialAudioSoundPrivate::getAPI()
{
auto *ep = QAudioEnginePrivate::get(engine);
if (!ep)
return nullptr;
return ep->resonanceAudio->api.get();
}
void QSpatialAudioSoundPrivate::setState(SharedPlaybackState state)
{
auto *ep = QAudioEnginePrivate::get(engine);
if (ep)
ep->setSoundPlaybackData(this, state);
m_playbackState = std::move(state);
}
QT_END_NAMESPACE