qt-everywhere-src-5.15.1/qtmultimedia/src/multimedia/audio/qsoundeffect_qaudio_p.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** 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"
	/****************************************************************************
	**
	** 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"