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 <QtCore/qloggingcategory.h>
#include <private/qplatformmediadevices_p.h>
 
static Q_LOGGING_CATEGORY(qLcSoundEffect, "qt.multimedia.soundeffect")
 
QT_BEGIN_NAMESPACE
 
Q_GLOBAL_STATIC(QSampleCache, sampleCache)
 
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_sample->data().size();
    }
    qint64 bytesAvailable() const override {
        if (m_sample->state() != QSample::Ready)
            return 0;
        return m_loopCount == QSoundEffect::Infinite
                   ? std::numeric_limits<qint64>::max() : m_runningCount * m_sample->data().size() - 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;
    QAudioSink *m_audioOutput = nullptr;
    QSample *m_sample = nullptr;
    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);
 
    QPlatformMediaDevices::instance()->prepareAudio();
}
 
void QSoundEffectPrivate::sampleReady()
{
    if (m_status == QSoundEffect::Error)
        return;
 
    qCDebug(qLcSoundEffect) << this << "sampleReady: sample size:" << m_sample->data().size();
    disconnect(m_sample, &QSample::error, this, &QSoundEffectPrivate::decoderError);
    disconnect(m_sample, &QSample::ready, this, &QSoundEffectPrivate::sampleReady);
    if (!m_audioOutput) {
        m_audioOutput = new QAudioSink(m_audioDevice, m_sample->format());
        connect(m_audioOutput, &QAudioSink::stateChanged, this, &QSoundEffectPrivate::stateChanged);
        if (!m_muted)
            m_audioOutput->setVolume(m_volume);
        else
            m_audioOutput->setVolume(0);
    }
    m_sampleReady = true;
    setStatus(QSoundEffect::Ready);
 
    if (m_playing && m_audioOutput->state() == QAudio::StoppedState) {
        qCDebug(qLcSoundEffect) << this << "starting playback on audiooutput";
        m_audioOutput->start(this);
    }
}
 
void QSoundEffectPrivate::decoderError()
{
    qWarning("QSoundEffect(qaudio): Error decoding source %ls", qUtf16Printable(m_url.toString()));
    disconnect(m_sample, &QSample::ready, this, &QSoundEffectPrivate::sampleReady);
    disconnect(m_sample, &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_sample->data().size();
    const char* sampleData = m_sample->data().constData();
 
    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_audioOutput) {
        m_audioOutput->stop();
        if (playing && !m_sampleReady)
            return;
    }
 
    if (m_playing == playing)
        return;
    m_playing = playing;
 
    if (m_audioOutput && playing)
        m_audioOutput->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();
    if (d->m_audioOutput) {
        d->m_audioOutput->stop();
        d->m_audioOutput->deleteLater();
        d->m_sample->release();
    }
    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) {
            QObject::disconnect(d->m_sample, &QSample::error, d, &QSoundEffectPrivate::decoderError);
            QObject::disconnect(d->m_sample, &QSample::ready, d, &QSoundEffectPrivate::sampleReady);
        }
        d->m_sample->release();
        d->m_sample = nullptr;
    }
 
    if (d->m_audioOutput) {
        QObject::disconnect(d->m_audioOutput, &QAudioSink::stateChanged, d, &QSoundEffectPrivate::stateChanged);
        d->m_audioOutput->stop();
        d->m_audioOutput->deleteLater();
        d->m_audioOutput = nullptr;
    }
 
    d->setStatus(QSoundEffect::Loading);
    d->m_sample = sampleCache()->requestSample(url);
    QObject::connect(d->m_sample, &QSample::error, d, &QSoundEffectPrivate::decoderError);
    QObject::connect(d->m_sample, &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_audioOutput && !d->m_muted)
        return d->m_audioOutput->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_audioOutput && !d->m_muted)
        d->m_audioOutput->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_audioOutput)
        d->m_audioOutput->setVolume(0);
    else if (!muted && d->m_audioOutput && d->m_muted)
        d->m_audioOutput->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"