| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // INTERNAL USE ONLY: Do NOT use for any other purpose. |
| // |
| |
| #include "qsoundeffect_qaudio_p.h" |
| |
| #include <QtCore/qcoreapplication.h> |
| #include <QtCore/qiodevice.h> |
| |
| //#include <QDebug> |
| //#define QT_QAUDIO_DEBUG 1 |
| |
| QT_BEGIN_NAMESPACE |
| |
| Q_GLOBAL_STATIC(QSampleCache, sampleCache) |
| |
| QSoundEffectPrivate::QSoundEffectPrivate(QObject *parent): |
| QObject(parent), |
| d(new PrivateSoundSource(this)) |
| { |
| } |
| |
| QSoundEffectPrivate::QSoundEffectPrivate(const QAudioDeviceInfo &audioDevice, QObject *parent) |
| : QObject(parent) |
| , d(new PrivateSoundSource(this, audioDevice)) |
| { |
| } |
| |
| QSoundEffectPrivate::~QSoundEffectPrivate() |
| { |
| } |
| |
| void QSoundEffectPrivate::release() |
| { |
| stop(); |
| if (d->m_audioOutput) { |
| d->m_audioOutput->stop(); |
| d->m_audioOutput->deleteLater(); |
| d->m_sample->release(); |
| } |
| delete d; |
| this->deleteLater(); |
| } |
| |
| QStringList QSoundEffectPrivate::supportedMimeTypes() |
| { |
| // Only return supported mime types if we have a audio device available |
| const QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput); |
| if (devices.size() <= 0) |
| return QStringList(); |
| |
| return QStringList() << QLatin1String("audio/x-wav") |
| << QLatin1String("audio/wav") |
| << QLatin1String("audio/wave") |
| << QLatin1String("audio/x-pn-wav"); |
| } |
| |
| QUrl QSoundEffectPrivate::source() const |
| { |
| return d->m_url; |
| } |
| |
| void QSoundEffectPrivate::setSource(const QUrl &url) |
| { |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "setSource current=" << d->m_url << ", to=" << url; |
| #endif |
| Q_ASSERT(d->m_url != url); |
| |
| stop(); |
| |
| d->m_url = url; |
| |
| d->m_sampleReady = false; |
| |
| if (url.isEmpty()) { |
| setStatus(QSoundEffect::Null); |
| return; |
| } |
| |
| if (!url.isValid()) { |
| setStatus(QSoundEffect::Error); |
| return; |
| } |
| |
| if (d->m_sample) { |
| if (!d->m_sampleReady) { |
| disconnect(d->m_sample, &QSample::error, d, &PrivateSoundSource::decoderError); |
| disconnect(d->m_sample, &QSample::ready, d, &PrivateSoundSource::sampleReady); |
| } |
| d->m_sample->release(); |
| d->m_sample = nullptr; |
| } |
| |
| if (d->m_audioOutput) { |
| disconnect(d->m_audioOutput, &QAudioOutput::stateChanged, d, &PrivateSoundSource::stateChanged); |
| d->m_audioOutput->stop(); |
| d->m_audioOutput->deleteLater(); |
| d->m_audioOutput = nullptr; |
| } |
| |
| setStatus(QSoundEffect::Loading); |
| d->m_sample = sampleCache()->requestSample(url); |
| connect(d->m_sample, &QSample::error, d, &PrivateSoundSource::decoderError); |
| connect(d->m_sample, &QSample::ready, d, &PrivateSoundSource::sampleReady); |
| |
| switch (d->m_sample->state()) { |
| case QSample::Ready: |
| d->sampleReady(); |
| break; |
| case QSample::Error: |
| d->decoderError(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| int QSoundEffectPrivate::loopCount() const |
| { |
| return d->m_loopCount; |
| } |
| |
| int QSoundEffectPrivate::loopsRemaining() const |
| { |
| return d->m_runningCount; |
| } |
| |
| void QSoundEffectPrivate::setLoopCount(int loopCount) |
| { |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "setLoopCount " << loopCount; |
| #endif |
| if (loopCount == 0) |
| loopCount = 1; |
| d->m_loopCount = loopCount; |
| if (d->m_playing) |
| setLoopsRemaining(loopCount); |
| } |
| |
| qreal QSoundEffectPrivate::volume() const |
| { |
| if (d->m_audioOutput && !d->m_muted) |
| return d->m_audioOutput->volume(); |
| |
| return d->m_volume; |
| } |
| |
| void QSoundEffectPrivate::setVolume(qreal volume) |
| { |
| d->m_volume = volume; |
| |
| if (d->m_audioOutput && !d->m_muted) |
| d->m_audioOutput->setVolume(volume); |
| |
| emit volumeChanged(); |
| } |
| |
| bool QSoundEffectPrivate::isMuted() const |
| { |
| return d->m_muted; |
| } |
| |
| void QSoundEffectPrivate::setMuted(bool muted) |
| { |
| 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 QSoundEffectPrivate::isLoaded() const |
| { |
| return d->m_status == QSoundEffect::Ready; |
| } |
| |
| |
| bool QSoundEffectPrivate::isPlaying() const |
| { |
| return d->m_playing; |
| } |
| |
| QSoundEffect::Status QSoundEffectPrivate::status() const |
| { |
| return d->m_status; |
| } |
| |
| void QSoundEffectPrivate::play() |
| { |
| d->m_offset = 0; |
| setLoopsRemaining(d->m_loopCount); |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "play"; |
| #endif |
| if (d->m_status == QSoundEffect::Null || d->m_status == QSoundEffect::Error) { |
| setStatus(QSoundEffect::Null); |
| return; |
| } |
| setPlaying(true); |
| if (d->m_audioOutput && d->m_audioOutput->state() == QAudio::StoppedState && d->m_sampleReady) |
| d->m_audioOutput->start(d); |
| } |
| |
| void QSoundEffectPrivate::stop() |
| { |
| if (!d->m_playing) |
| return; |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "stop()"; |
| #endif |
| d->m_offset = 0; |
| |
| setPlaying(false); |
| |
| if (d->m_audioOutput) |
| d->m_audioOutput->stop(); |
| } |
| |
| void QSoundEffectPrivate::setStatus(QSoundEffect::Status status) |
| { |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "setStatus" << status; |
| #endif |
| if (d->m_status == status) |
| return; |
| bool oldLoaded = isLoaded(); |
| d->m_status = status; |
| emit statusChanged(); |
| if (oldLoaded != isLoaded()) |
| emit loadedChanged(); |
| } |
| |
| void QSoundEffectPrivate::setPlaying(bool playing) |
| { |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "setPlaying(" << playing << ")"; |
| #endif |
| if (d->m_playing == playing) |
| return; |
| d->m_playing = playing; |
| emit playingChanged(); |
| } |
| |
| void QSoundEffectPrivate::setLoopsRemaining(int loopsRemaining) |
| { |
| if (d->m_runningCount == loopsRemaining) |
| return; |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "setLoopsRemaining " << loopsRemaining; |
| #endif |
| d->m_runningCount = loopsRemaining; |
| emit loopsRemainingChanged(); |
| } |
| |
| /* Categories are ignored */ |
| QString QSoundEffectPrivate::category() const |
| { |
| return d->m_category; |
| } |
| |
| void QSoundEffectPrivate::setCategory(const QString &category) |
| { |
| if (d->m_category != category && !d->m_playing) { |
| d->m_category = category; |
| emit categoryChanged(); |
| } |
| } |
| |
| PrivateSoundSource::PrivateSoundSource(QSoundEffectPrivate *s, const QAudioDeviceInfo &audioDevice) |
| : QIODevice(s) |
| , m_audioDevice(audioDevice) |
| { |
| soundeffect = s; |
| m_category = QLatin1String("game"); |
| open(QIODevice::ReadOnly); |
| } |
| |
| void PrivateSoundSource::sampleReady() |
| { |
| if (m_status == QSoundEffect::Error) |
| return; |
| |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "sampleReady "<<m_playing; |
| #endif |
| disconnect(m_sample, &QSample::error, this, &PrivateSoundSource::decoderError); |
| disconnect(m_sample, &QSample::ready, this, &PrivateSoundSource::sampleReady); |
| if (!m_audioOutput) { |
| if (m_audioDevice.isNull()) |
| m_audioOutput = new QAudioOutput(m_sample->format()); |
| else |
| m_audioOutput = new QAudioOutput(m_audioDevice, m_sample->format()); |
| connect(m_audioOutput, &QAudioOutput::stateChanged, this, &PrivateSoundSource::stateChanged); |
| if (!m_muted) |
| m_audioOutput->setVolume(m_volume); |
| else |
| m_audioOutput->setVolume(0); |
| } |
| m_sampleReady = true; |
| soundeffect->setStatus(QSoundEffect::Ready); |
| |
| if (m_playing && m_audioOutput->state() == QAudio::StoppedState) |
| m_audioOutput->start(this); |
| } |
| |
| void PrivateSoundSource::decoderError() |
| { |
| qWarning("QSoundEffect(qaudio): Error decoding source %ls", qUtf16Printable(m_url.toString())); |
| disconnect(m_sample, &QSample::ready, this, &PrivateSoundSource::sampleReady); |
| disconnect(m_sample, &QSample::error, this, &PrivateSoundSource::decoderError); |
| m_playing = false; |
| soundeffect->setStatus(QSoundEffect::Error); |
| } |
| |
| void PrivateSoundSource::stateChanged(QAudio::State state) |
| { |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << this << "stateChanged " << state; |
| #endif |
| if ((state == QAudio::IdleState && m_runningCount == 0) |
| || (state == QAudio::StoppedState && m_audioOutput->error() != QAudio::NoError)) |
| emit soundeffect->stop(); |
| } |
| |
| qint64 PrivateSoundSource::readData(char *data, qint64 len) |
| { |
| if ((m_runningCount > 0 || m_runningCount == QSoundEffect::Infinite) && m_playing) { |
| |
| if (m_sample->state() != QSample::Ready) |
| return 0; |
| |
| qint64 bytesWritten = 0; |
| |
| const int periodSize = m_audioOutput->periodSize(); |
| const int sampleSize = m_sample->data().size(); |
| const char* sampleData = m_sample->data().constData(); |
| |
| // Some systems can have large buffers we only need a max of three |
| int periodsFree = qMin(3, (int)(m_audioOutput->bytesFree()/periodSize)); |
| int dataOffset = 0; |
| |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "bytesFree=" << m_audioOutput->bytesFree() << ", can fit " << periodsFree << " periodSize() chunks"; |
| #endif |
| |
| while ((periodsFree > 0) && (bytesWritten + periodSize <= len)) { |
| |
| if (sampleSize - m_offset >= periodSize) { |
| // We can fit a whole period of data |
| memcpy(data + dataOffset, sampleData + m_offset, periodSize); |
| m_offset += periodSize; |
| dataOffset += periodSize; |
| bytesWritten += periodSize; |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "WHOLE PERIOD: bytesWritten=" << bytesWritten << ", offset=" << m_offset |
| << ", filesize=" << sampleSize; |
| #endif |
| } else { |
| // We are at end of sound, first write what is left of current sound |
| memcpy(data + dataOffset, sampleData + m_offset, sampleSize - m_offset); |
| bytesWritten += sampleSize - m_offset; |
| int wrapLen = periodSize - (sampleSize - m_offset); |
| if (wrapLen > sampleSize) |
| wrapLen = sampleSize; |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "END OF SOUND: bytesWritten=" << bytesWritten << ", offset=" << m_offset |
| << ", part1=" << (sampleSize-m_offset); |
| #endif |
| dataOffset += (sampleSize - m_offset); |
| m_offset = 0; |
| |
| if (m_runningCount > 0 && m_runningCount != QSoundEffect::Infinite) |
| soundeffect->setLoopsRemaining(m_runningCount-1); |
| |
| if (m_runningCount > 0 || m_runningCount == QSoundEffect::Infinite) { |
| // There are still more loops of this sound to play, append the start of sound to make up full period |
| memcpy(data + dataOffset, sampleData + m_offset, wrapLen); |
| m_offset += wrapLen; |
| dataOffset += wrapLen; |
| bytesWritten += wrapLen; |
| #ifdef QT_QAUDIO_DEBUG |
| qDebug() << "APPEND START FOR FULL PERIOD: bytesWritten=" << bytesWritten << ", offset=" << m_offset |
| << ", part2=" << wrapLen; |
| qDebug() << "part1 + part2 should be a period " << periodSize; |
| #endif |
| } |
| } |
| if (m_runningCount == 0) |
| break; |
| |
| periodsFree--; |
| } |
| return bytesWritten; |
| } |
| |
| return 0; |
| } |
| |
| qint64 PrivateSoundSource::writeData(const char *data, qint64 len) |
| { |
| Q_UNUSED(data) |
| Q_UNUSED(len) |
| return 0; |
| } |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_qsoundeffect_qaudio_p.cpp" |