qsoundeffect.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 <QtMultimedia/private/qtmultimediaglobal_p.h>
#include "qsoundeffect.h"
#include "qsamplecache_p.h"
#include "qaudiodevice.h"
#include "qaudiosink.h"
#include "qmediadevices.h"
#include "qaudiobuffer.h"
#include <QtCore/qloggingcategory.h>
#include <private/qplatformmediadevices_p.h>
#include <private/qplatformmediaintegration_p.h>
#include <private/qplatformaudioresampler_p.h>
 
static Q_LOGGING_CATEGORY(qLcSoundEffect, "qt.multimedia.soundeffect")
 
QT_BEGIN_NAMESPACE
 
Q_GLOBAL_STATIC(QSampleCache, sampleCache)
 
namespace
{
struct AudioSinkDeleter
{
    void operator ()(QAudioSink* sink) const
    {
        sink->stop();
        // Investigate:should we just delete?
        sink->deleteLater();
    }
};
 
struct SampleDeleter
{
    void operator ()(QSample* sample) const
    {
        sample->release();
    }
};
}
 
class QSoundEffectPrivate : public QIODevice
{
public:
    QSoundEffectPrivate(QSoundEffect *q, const QAudioDevice &audioDevice = QAudioDevice());
    ~QSoundEffectPrivate() override = default;
 
    qint64 readData(char *data, qint64 len) override;
    qint64 writeData(const char *data, qint64 len) override;
    qint64 size() const override {
        if (m_sample->state() != QSample::Ready)
            return 0;
        return m_loopCount == QSoundEffect::Infinite ? 0 : m_loopCount * m_audioBuffer.byteCount();
    }
    qint64 bytesAvailable() const override {
        if (m_sample->state() != QSample::Ready)
            return 0;
        if (m_loopCount == QSoundEffect::Infinite)
            return std::numeric_limits<qint64>::max();
        return m_runningCount * m_audioBuffer.byteCount() - m_offset;
    }
    bool isSequential() const override {
        return m_loopCount == QSoundEffect::Infinite;
    }
    bool atEnd() const override {
        return m_runningCount == 0;
    }
 
    void setLoopsRemaining(int loopsRemaining);
    void setStatus(QSoundEffect::Status status);
    void setPlaying(bool playing);
 
public Q_SLOTS:
    void sampleReady();
    void decoderError();
    void stateChanged(QAudio::State);
 
public:
    QSoundEffect *q_ptr;
    QUrl m_url;
    int m_loopCount = 1;
    int m_runningCount = 0;
    bool m_playing = false;
    QSoundEffect::Status m_status = QSoundEffect::Null;
    std::unique_ptr<QAudioSink, AudioSinkDeleter> m_audioSink;
    std::unique_ptr<QSample, SampleDeleter> m_sample;
    QAudioBuffer m_audioBuffer;
    bool m_muted = false;
    float m_volume = 1.0;
    bool m_sampleReady = false;
    qint64 m_offset = 0;
    QAudioDevice m_audioDevice;
};
 
QSoundEffectPrivate::QSoundEffectPrivate(QSoundEffect *q, const QAudioDevice &audioDevice)
    : QIODevice(q)
    , q_ptr(q)
    , m_audioDevice(audioDevice)
{
    open(QIODevice::ReadOnly);
 
    QPlatformMediaIntegration::instance()->mediaDevices()->prepareAudio();
}
 
void QSoundEffectPrivate::sampleReady()
{
    if (m_status == QSoundEffect::Error)
        return;
 
    qCDebug(qLcSoundEffect) << this << "sampleReady: sample size:" << m_sample->data().size();
    disconnect(m_sample.get(), &QSample::error, this, &QSoundEffectPrivate::decoderError);
    disconnect(m_sample.get(), &QSample::ready, this, &QSoundEffectPrivate::sampleReady);
    if (!m_audioSink) {
        const auto audioDevice =
                m_audioDevice.isNull() ? QMediaDevices::defaultAudioOutput() : m_audioDevice;
 
        if (audioDevice.isNull()) {
            // We are likely on a virtual machine, for example in CI
            qCCritical(qLcSoundEffect) << "Failed to play sound. No audio devices present.";
            setStatus(QSoundEffect::Error);
            return;
        }
 
        const auto &sampleFormat = m_sample->format();
        const auto sampleChannelConfig =
                sampleFormat.channelConfig() == QAudioFormat::ChannelConfigUnknown
                ? QAudioFormat::defaultChannelConfigForChannelCount(sampleFormat.channelCount())
                : sampleFormat.channelConfig();
 
        if (sampleChannelConfig != audioDevice.channelConfiguration()
            && audioDevice.channelConfiguration() != QAudioFormat::ChannelConfigUnknown) {
            qCDebug(qLcSoundEffect) << "Create resampler for channels mapping: config"
                                    << sampleFormat.channelConfig() << "=> config"
                                    << audioDevice.channelConfiguration();
            auto outputFormat = sampleFormat;
            outputFormat.setChannelConfig(audioDevice.channelConfiguration());
 
            const auto resampler = QPlatformMediaIntegration::instance()->createAudioResampler(
                    m_sample->format(), outputFormat);
            if (resampler)
                m_audioBuffer = resampler.value()->resample(m_sample->data().constData(),
                                                            m_sample->data().size());
            else
                qCDebug(qLcSoundEffect) << "Cannot create resampler for channels mapping";
        }
 
        if (!m_audioBuffer.isValid())
            m_audioBuffer = QAudioBuffer(m_sample->data(), m_sample->format());
 
        m_audioSink.reset(new QAudioSink(audioDevice, m_audioBuffer.format()));
 
        connect(m_audioSink.get(), &QAudioSink::stateChanged, this, &QSoundEffectPrivate::stateChanged);
        if (!m_muted)
            m_audioSink->setVolume(m_volume);
        else
            m_audioSink->setVolume(0);
    }
    m_sampleReady = true;
    setStatus(QSoundEffect::Ready);
 
    if (m_playing && m_audioSink->state() == QAudio::StoppedState) {
        qCDebug(qLcSoundEffect) << this << "starting playback on audiooutput";
        m_audioSink->start(this);
    }
}
 
void QSoundEffectPrivate::decoderError()
{
    qWarning("QSoundEffect(qaudio): Error decoding source %ls", qUtf16Printable(m_url.toString()));
    disconnect(m_sample.get(), &QSample::ready, this, &QSoundEffectPrivate::sampleReady);
    disconnect(m_sample.get(), &QSample::error, this, &QSoundEffectPrivate::decoderError);
    m_playing = false;
    setStatus(QSoundEffect::Error);
}
 
void QSoundEffectPrivate::stateChanged(QAudio::State state)
{
    qCDebug(qLcSoundEffect) << this << "stateChanged " << state;
    if ((state == QAudio::IdleState && m_runningCount == 0) || state == QAudio::StoppedState)
        q_ptr->stop();
}
 
qint64 QSoundEffectPrivate::readData(char *data, qint64 len)
{
    qCDebug(qLcSoundEffect) << this << "readData" << len << m_runningCount;
    if (!len)
        return 0;
    if (m_sample->state() != QSample::Ready)
        return 0;
    if (m_runningCount == 0 || !m_playing)
        return 0;
 
    qint64 bytesWritten = 0;
 
    const int sampleSize = m_audioBuffer.byteCount();
    const char *sampleData = m_audioBuffer.constData<char>();
 
    while (len && m_runningCount) {
        int toWrite = qMin(sampleSize - m_offset, len);
        memcpy(data, sampleData + m_offset, toWrite);
        bytesWritten += toWrite;
        data += toWrite;
        len -= toWrite;
        m_offset += toWrite;
        if (m_offset >= sampleSize) {
            if (m_runningCount > 0 && m_runningCount != QSoundEffect::Infinite)
                setLoopsRemaining(m_runningCount - 1);
            m_offset = 0;
        }
    }
 
    return bytesWritten;
}
 
qint64 QSoundEffectPrivate::writeData(const char *data, qint64 len)
{
    Q_UNUSED(data);
    Q_UNUSED(len);
    return 0;
}
 
void QSoundEffectPrivate::setLoopsRemaining(int loopsRemaining)
{
    if (m_runningCount == loopsRemaining)
        return;
    qCDebug(qLcSoundEffect) << this << "setLoopsRemaining " << loopsRemaining;
    m_runningCount = loopsRemaining;
    emit q_ptr->loopsRemainingChanged();
}
 
void QSoundEffectPrivate::setStatus(QSoundEffect::Status status)
{
    qCDebug(qLcSoundEffect) << this << "setStatus" << status;
    if (m_status == status)
        return;
    bool oldLoaded = q_ptr->isLoaded();
    m_status = status;
    emit q_ptr->statusChanged();
    if (oldLoaded != q_ptr->isLoaded())
        emit q_ptr->loadedChanged();
}
 
void QSoundEffectPrivate::setPlaying(bool playing)
{
    qCDebug(qLcSoundEffect) << this << "setPlaying(" << playing << ")" << m_playing;
    if (m_audioSink) {
        m_audioSink->stop();
        if (playing && !m_sampleReady)
            return;
    }
 
    if (m_playing == playing)
        return;
    m_playing = playing;
 
    if (m_audioSink && playing)
        m_audioSink->start(this);
 
    emit q_ptr->playingChanged();
}
 
QSoundEffect::QSoundEffect(QObject *parent)
    : QSoundEffect(QAudioDevice(), parent)
{
}
 
QSoundEffect::QSoundEffect(const QAudioDevice &audioDevice, QObject *parent)
    : QObject(parent)
    , d(new QSoundEffectPrivate(this, audioDevice))
{
}
 
QSoundEffect::~QSoundEffect()
{
    stop();
    d->m_audioSink.reset();
    d->m_sample.reset();
    delete d;
}
 
QStringList QSoundEffect::supportedMimeTypes()
{
    // Only return supported mime types if we have a audio device available
    const QList<QAudioDevice> devices = QMediaDevices::audioOutputs();
    if (devices.isEmpty())
        return QStringList();
 
    return QStringList() << QLatin1String("audio/x-wav")
                         << QLatin1String("audio/wav")
                         << QLatin1String("audio/wave")
                         << QLatin1String("audio/x-pn-wav");
}
 
QUrl QSoundEffect::source() const
{
    return d->m_url;
}
 
void QSoundEffect::setSource(const QUrl &url)
{
    qCDebug(qLcSoundEffect) << this << "setSource current=" << d->m_url << ", to=" << url;
    if (d->m_url == url)
        return;
 
    Q_ASSERT(d->m_url != url);
 
    stop();
 
    d->m_url = url;
 
    d->m_sampleReady = false;
 
    if (url.isEmpty()) {
        d->setStatus(QSoundEffect::Null);
        return;
    }
 
    if (!url.isValid()) {
        d->setStatus(QSoundEffect::Error);
        return;
    }
 
    if (d->m_sample) {
        if (!d->m_sampleReady) {
            disconnect(d->m_sample.get(), &QSample::error, d, &QSoundEffectPrivate::decoderError);
            disconnect(d->m_sample.get(), &QSample::ready, d, &QSoundEffectPrivate::sampleReady);
        }
        d->m_sample->release();
        d->m_sample = nullptr;
    }
 
    if (d->m_audioSink) {
        disconnect(d->m_audioSink.get(), &QAudioSink::stateChanged, d, &QSoundEffectPrivate::stateChanged);
        d->m_audioSink.reset();
    }
 
    d->setStatus(QSoundEffect::Loading);
    d->m_sample.reset(sampleCache()->requestSample(url));
    connect(d->m_sample.get(), &QSample::error, d, &QSoundEffectPrivate::decoderError);
    connect(d->m_sample.get(), &QSample::ready, d, &QSoundEffectPrivate::sampleReady);
 
    switch (d->m_sample->state()) {
    case QSample::Ready:
        d->sampleReady();
        break;
    case QSample::Error:
        d->decoderError();
        break;
    default:
        break;
    }
 
    emit sourceChanged();
}
 
int QSoundEffect::loopCount() const
{
    return d->m_loopCount;
}
 
void QSoundEffect::setLoopCount(int loopCount)
{
    if (loopCount < 0 && loopCount != Infinite) {
        qWarning("SoundEffect: loops should be SoundEffect.Infinite, 0 or positive integer");
        return;
    }
    if (loopCount == 0)
        loopCount = 1;
    if (d->m_loopCount == loopCount)
        return;
 
    d->m_loopCount = loopCount;
    if (d->m_playing)
        d->setLoopsRemaining(loopCount);
    emit loopCountChanged();
}
 
QAudioDevice QSoundEffect::audioDevice()
{
    return d->m_audioDevice;
}
 
void QSoundEffect::setAudioDevice(const QAudioDevice &device)
{
    if (d->m_audioDevice == device)
        return;
    // ### recreate the QAudioSink if needed
    d->m_audioDevice = device;
    emit audioDeviceChanged();
}
 
int QSoundEffect::loopsRemaining() const
{
    return d->m_runningCount;
}
 
 
float QSoundEffect::volume() const
{
    if (d->m_audioSink && !d->m_muted)
        return d->m_audioSink->volume();
 
    return d->m_volume;
}
 
void QSoundEffect::setVolume(float volume)
{
    volume = qBound(0.0f, volume, 1.0f);
    if (d->m_volume == volume)
        return;
 
    d->m_volume = volume;
 
    if (d->m_audioSink && !d->m_muted)
        d->m_audioSink->setVolume(volume);
 
    emit volumeChanged();
}
 
bool QSoundEffect::isMuted() const
{
    return d->m_muted;
}
 
void QSoundEffect::setMuted(bool muted)
{
    if (d->m_muted == muted)
        return;
 
    if (muted && d->m_audioSink)
        d->m_audioSink->setVolume(0);
    else if (!muted && d->m_audioSink && d->m_muted)
        d->m_audioSink->setVolume(d->m_volume);
 
    d->m_muted = muted;
    emit mutedChanged();
}
 
bool QSoundEffect::isLoaded() const
{
    return d->m_status == QSoundEffect::Ready;
}
 
void QSoundEffect::play()
{
    d->m_offset = 0;
    d->setLoopsRemaining(d->m_loopCount);
    qCDebug(qLcSoundEffect) << this << "play" << d->m_loopCount << d->m_runningCount;
    if (d->m_status == QSoundEffect::Null || d->m_status == QSoundEffect::Error) {
        d->setStatus(QSoundEffect::Null);
        return;
    }
    d->setPlaying(true);
}
 
bool QSoundEffect::isPlaying() const
{
    return d->m_playing;
}
 
QSoundEffect::Status QSoundEffect::status() const
{
    return d->m_status;
}
 
void QSoundEffect::stop()
{
    if (!d->m_playing)
        return;
    qCDebug(qLcSoundEffect) << "stop()";
    d->m_offset = 0;
 
    d->setPlaying(false);
}
 
/* Signals */
 
QT_END_NAMESPACE
 
#include "moc_qsoundeffect.cpp"