qt-everywhere-src-5.15.1/qtmultimedia/src/multimedia/audio/qaudiobuffer.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$
 **
 ****************************************************************************/

 #include "qaudiobuffer.h"
 #include "qaudiobuffer_p.h"

 #include <QObject>
 #include <QDebug>

 QT_BEGIN_NAMESPACE


 static void qRegisterAudioBufferMetaTypes()
 {
     qRegisterMetaType<QAudioBuffer>();
 }

 Q_CONSTRUCTOR_FUNCTION(qRegisterAudioBufferMetaTypes)


 class QAudioBufferPrivate : public QSharedData
 {
 public:
     QAudioBufferPrivate(QAbstractAudioBuffer *provider)
         : mProvider(provider)
         , mCount(1)
     {
     }

     ~QAudioBufferPrivate()
     {
         if (mProvider)
             mProvider->release();
     }

     void ref()
     {
         mCount.ref();
     }

     void deref()
     {
         if (!mCount.deref())
             delete this;
     }

     QAudioBufferPrivate *clone();

     static QAudioBufferPrivate *acquire(QAudioBufferPrivate *other)
     {
         if (!other)
             return nullptr;

         // Ref the other (if there are extant data() pointers, they will
         // also point here - it's a feature, not a bug, like QByteArray)
         other->ref();
         return other;
     }

     QAbstractAudioBuffer *mProvider;
     QAtomicInt mCount;
 };

 // Private class to go in .cpp file
 class QMemoryAudioBufferProvider : public QAbstractAudioBuffer {
 public:
     QMemoryAudioBufferProvider(const void *data, int frameCount, const QAudioFormat &format, qint64 startTime)
         : mStartTime(startTime)
         , mFrameCount(frameCount)
         , mFormat(format)
     {
         int numBytes = format.bytesForFrames(frameCount);
         if (numBytes > 0) {
             mBuffer = malloc(numBytes);
             if (!mBuffer) {
                 // OOM, if that's likely
                 mStartTime = -1;
                 mFrameCount = 0;
                 mFormat = QAudioFormat();
             } else {
                 // Allocated, see if we have data to copy
                 if (data) {
                     memcpy(mBuffer, data, numBytes);
                 } else {
                     // We have to fill with the zero value..
                     switch (format.sampleType()) {
                         case QAudioFormat::SignedInt:
                             // Signed int means 0x80, 0x8000 is zero
                             // XXX this is not right for > 8 bits(0x8080 vs 0x8000)
                             memset(mBuffer, 0x80, numBytes);
                             break;
                         default:
                             memset(mBuffer, 0x0, numBytes);
                     }
                 }
             }
         } else
             mBuffer = nullptr;
     }

     ~QMemoryAudioBufferProvider()
     {
         if (mBuffer)
             free(mBuffer);
     }

     void release() override {delete this;}
     QAudioFormat format() const override {return mFormat;}
     qint64 startTime() const override {return mStartTime;}
     int frameCount() const override {return mFrameCount;}

     void *constData() const override {return mBuffer;}

     void *writableData() override {return mBuffer;}
     QAbstractAudioBuffer *clone() const override
     {
         return new QMemoryAudioBufferProvider(mBuffer, mFrameCount, mFormat, mStartTime);
     }

     void *mBuffer;
     qint64 mStartTime;
     int mFrameCount;
     QAudioFormat mFormat;
 };

 QAudioBufferPrivate *QAudioBufferPrivate::clone()
 {
     // We want to create a single bufferprivate with a
     // single qaab
     // This should only be called when the count is > 1
     Q_ASSERT(mCount.loadRelaxed() > 1);

     if (mProvider) {
         QAbstractAudioBuffer *abuf = mProvider->clone();

         if (!abuf) {
             abuf = new QMemoryAudioBufferProvider(mProvider->constData(), mProvider->frameCount(), mProvider->format(), mProvider->startTime());
         }

         if (abuf) {
             return new QAudioBufferPrivate(abuf);
         }
     }

     return nullptr;
 }

 /*!
     \class QAbstractAudioBuffer
     \internal
 */

 /*!
     \class QAudioBuffer
     \inmodule QtMultimedia
     \ingroup multimedia
     \ingroup multimedia_audio
     \brief The QAudioBuffer class represents a collection of audio samples with a specific format and sample rate.
 */
 // ^ Mostly useful with probe or decoder

 /*!
     Create a new, empty, invalid buffer.
  */
 QAudioBuffer::QAudioBuffer()
     : d(nullptr)
 {
 }

 /*!
     \internal
     Create a new audio buffer from the supplied \a provider.  This
     constructor is typically only used when handling certain hardware
     or media framework specific buffers, and generally isn't useful
     in application code.
  */
 QAudioBuffer::QAudioBuffer(QAbstractAudioBuffer *provider)
     : d(new QAudioBufferPrivate(provider))
 {
 }
 /*!
     Creates a new audio buffer from \a other.  Generally
     this will have copy-on-write semantics - a copy will
     only be made when it has to be.
  */
 QAudioBuffer::QAudioBuffer(const QAudioBuffer &other)
 {
     d = QAudioBufferPrivate::acquire(other.d);
 }

 /*!
     Creates a new audio buffer from the supplied \a data, in the
     given \a format.  The format will determine how the number
     and sizes of the samples are interpreted from the \a data.

     If the supplied \a data is not an integer multiple of the
     calculated frame size, the excess data will not be used.

     This audio buffer will copy the contents of \a data.

     \a startTime (in microseconds) indicates when this buffer
     starts in the stream.
     If this buffer is not part of a stream, set it to -1.
  */
 QAudioBuffer::QAudioBuffer(const QByteArray &data, const QAudioFormat &format, qint64 startTime)
 {
     if (format.isValid()) {
         int frameCount = format.framesForBytes(data.size());
         d = new QAudioBufferPrivate(new QMemoryAudioBufferProvider(data.constData(), frameCount, format, startTime));
     } else
         d = nullptr;
 }

 /*!
     Creates a new audio buffer with space for \a numFrames frames of
     the given \a format.  The individual samples will be initialized
     to the default for the format.

     \a startTime (in microseconds) indicates when this buffer
     starts in the stream.
     If this buffer is not part of a stream, set it to -1.
  */
 QAudioBuffer::QAudioBuffer(int numFrames, const QAudioFormat &format, qint64 startTime)
 {
     if (format.isValid())
         d = new QAudioBufferPrivate(new QMemoryAudioBufferProvider(nullptr, numFrames, format, startTime));
     else
         d = nullptr;
 }

 /*!
     Assigns the \a other buffer to this.
  */
 QAudioBuffer &QAudioBuffer::operator =(const QAudioBuffer &other)
 {
     if (this->d != other.d) {
         if (d)
             d->deref();
         d = QAudioBufferPrivate::acquire(other.d);
     }
     return *this;
 }

 /*!
     Destroys this audio buffer.
  */
 QAudioBuffer::~QAudioBuffer()
 {
     if (d)
         d->deref();
 }

 /*!
     Returns true if this is a valid buffer.  A valid buffer
     has more than zero frames in it and a valid format.
  */
 bool QAudioBuffer::isValid() const
 {
     if (!d || !d->mProvider)
         return false;
     return d->mProvider->format().isValid() && (d->mProvider->frameCount() > 0);
 }

 /*!
     Returns the \l {QAudioFormat}{format} of this buffer.

     Several properties of this format influence how
     the \l duration() or \l byteCount() are calculated
     from the \l frameCount().
  */
 QAudioFormat QAudioBuffer::format() const
 {
     if (!isValid())
         return QAudioFormat();
     return d->mProvider->format();
 }

 /*!
     Returns the number of complete audio frames in this buffer.

     An audio frame is an interleaved set of one sample per channel
     for the same instant in time.
 */
 int QAudioBuffer::frameCount() const
 {
     if (!isValid())
         return 0;
     return d->mProvider->frameCount();
 }

 /*!
     Returns the number of samples in this buffer.

     If the format of this buffer has multiple channels,
     then this count includes all channels.  This means
     that a stereo buffer with 1000 samples in total will
     have 500 left samples and 500 right samples (interleaved),
     and this function will return 1000.

     \sa frameCount()
 */
 int QAudioBuffer::sampleCount() const
 {
     if (!isValid())
         return 0;

     return frameCount() * format().channelCount();
 }

 /*!
     Returns the size of this buffer, in bytes.
  */
 int QAudioBuffer::byteCount() const
 {
     const QAudioFormat f(format());
     return format().bytesForFrames(frameCount());
 }

 /*!
     Returns the duration of audio in this buffer, in microseconds.

     This depends on the \l format(), and the \l frameCount().
 */
 qint64 QAudioBuffer::duration() const
 {
     return format().durationForFrames(frameCount());
 }

 /*!
     Returns the time in a stream that this buffer starts at (in microseconds).

     If this buffer is not part of a stream, this will return -1.
  */
 qint64 QAudioBuffer::startTime() const
 {
     if (!isValid())
         return -1;
     return d->mProvider->startTime();
 }

 /*!
     Returns a pointer to this buffer's data.  You can only read it.

     This method is preferred over the const version of \l data() to
     prevent unnecessary copying.

     There is also a templatized version of this constData() function that
     allows you to retrieve a specific type of read-only pointer to
     the data.  Note that there is no checking done on the format of
     the audio buffer - this is simply a convenience function.

     \code
     // With a 16bit sample buffer:
     const quint16 *data = buffer->constData<quint16>();
     \endcode

 */
 const void* QAudioBuffer::constData() const
 {
     if (!isValid())
         return nullptr;
     return d->mProvider->constData();
 }

 /*!
     Returns a pointer to this buffer's data.  You can only read it.

     You should use the \l constData() function rather than this
     to prevent accidental deep copying.

     There is also a templatized version of this data() function that
     allows you to retrieve a specific type of read-only pointer to
     the data.  Note that there is no checking done on the format of
     the audio buffer - this is simply a convenience function.

     \code
     // With a 16bit sample const buffer:
     const quint16 *data = buffer->data<quint16>();
     \endcode
 */
 const void* QAudioBuffer::data() const
 {
     if (!isValid())
         return nullptr;
     return d->mProvider->constData();
 }


 /*
     Template data/constData functions caused override problems with qdoc,
     so moved their docs into the non template versions.
 */

 /*!
     Returns a pointer to this buffer's data.  You can modify the
     data through the returned pointer.

     Since QAudioBuffers can share the actual sample data, calling
     this function will result in a deep copy being made if there
     are any other buffers using the sample.  You should avoid calling
     this unless you really need to modify the data.

     This pointer will remain valid until the underlying storage is
     detached.  In particular, if you obtain a pointer, and then
     copy this audio buffer, changing data through this pointer may
     change both buffer instances.  Calling \l data() on either instance
     will again cause a deep copy to be made, which may invalidate
     the pointers returned from this function previously.

     There is also a templatized version of data() allows you to retrieve
     a specific type of pointer to the data.  Note that there is no
     checking done on the format of the audio buffer - this is
     simply a convenience function.

     \code
     // With a 16bit sample buffer:
     quint16 *data = buffer->data<quint16>(); // May cause deep copy
     \endcode
 */
 void *QAudioBuffer::data()
 {
     if (!isValid())
         return nullptr;

     if (d->mCount.loadRelaxed() != 1) {
         // Can't share a writable buffer
         // so we need to detach
         QAudioBufferPrivate *newd = d->clone();

         // This shouldn't happen
         if (!newd)
             return nullptr;

         d->deref();
         d = newd;
     }

     // We're (now) the only user of this qaab, so
     // see if it's writable directly
     void *buffer = d->mProvider->writableData();
     if (buffer) {
         return buffer;
     }

     // Wasn't writable, so turn it into a memory provider
     QAbstractAudioBuffer *memBuffer = new QMemoryAudioBufferProvider(constData(), frameCount(), format(), startTime());

     if (memBuffer) {
         d->mProvider->release();
         d->mCount.storeRelaxed(1);
         d->mProvider = memBuffer;

         return memBuffer->writableData();
     }

     return nullptr;
 }

 // Template helper classes worth documenting

 /*!
     \class QAudioBuffer::StereoFrameDefault
     \internal

     Just a trait class for the default value.
 */

 /*!
     \class QAudioBuffer::StereoFrame
     \brief The StereoFrame class provides a simple wrapper for a stereo audio frame.
     \inmodule QtMultimedia
     \ingroup multimedia
     \ingroup multimedia_audio

     This templatized structure lets you treat a block of individual samples as an
     interleaved stereo stream frame.  This is most useful when used with the templatized
     \l {QAudioBuffer::data()}{data()} functions of QAudioBuffer.  Generally the data
     is accessed as a pointer, so no copying should occur.

     There are some predefined instantiations of this template for working with common
     stereo sample depths in a convenient way.

     This frame structure has \e left and \e right members for accessing individual channel data.

     For example:
     \code
     // Assuming 'buffer' is an unsigned 16 bit stereo buffer..
     QAudioBuffer::S16U *frames = buffer->data<QAudioBuffer::S16U>();
     for (int i=0; i < buffer->frameCount(); i++) {
         qSwap(frames[i].left, frames[i].right);
     }
     \endcode

     \sa QAudioBuffer::S8U, QAudioBuffer::S8S, QAudioBuffer::S16S, QAudioBuffer::S16U, QAudioBuffer::S32F
 */

 /*!
     \fn template <typename T> QAudioBuffer::StereoFrame<T>::StereoFrame()

     Constructs a new frame with the "silent" value for this
     sample format (0 for signed formats and floats, 0x8* for unsigned formats).
 */

 /*!
     \fn template <typename T> QAudioBuffer::StereoFrame<T>::StereoFrame(T leftSample, T rightSample)

     Constructs a new frame with the supplied \a leftSample and \a rightSample values.
 */

 /*!
     \fn template <typename T> QAudioBuffer::StereoFrame<T>::operator=(const StereoFrame &other)

     Assigns \a other to this frame.
  */


 /*!
     \fn template <typename T> QAudioBuffer::StereoFrame<T>::average() const

     Returns the arithmetic average of the left and right samples.
  */

 /*! \fn template <typename T> QAudioBuffer::StereoFrame<T>::clear()

     Sets the values of this frame to the "silent" value.
 */

 /*!
     \variable QAudioBuffer::StereoFrame::left
     \brief the left sample
 */

 /*!
     \variable QAudioBuffer::StereoFrame::right
     \brief the right sample
 */

 /*!
     \typedef QAudioBuffer::S8U

     This is a predefined specialization for an unsigned stereo 8 bit sample.  Each
     channel is an \e {unsigned char}.
 */
 /*!
     \typedef QAudioBuffer::S8S

     This is a predefined specialization for a signed stereo 8 bit sample.  Each
     channel is a \e {signed char}.
 */
 /*!
     \typedef QAudioBuffer::S16U

     This is a predefined specialization for an unsigned stereo 16 bit sample.  Each
     channel is an \e {unsigned short}.
 */
 /*!
     \typedef QAudioBuffer::S16S

     This is a predefined specialization for a signed stereo 16 bit sample.  Each
     channel is a \e {signed short}.
 */
 /*!
     \typedef QAudioBuffer::S32F

     This is a predefined specialization for an 32 bit float sample.  Each
     channel is a \e float.
 */

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** 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$
	**
	****************************************************************************/

	#include "qaudiobuffer.h"
	#include "qaudiobuffer_p.h"

	#include <QObject>
	#include <QDebug>

	QT_BEGIN_NAMESPACE


	static void qRegisterAudioBufferMetaTypes()
	{
	qRegisterMetaType<QAudioBuffer>();
	}

	Q_CONSTRUCTOR_FUNCTION(qRegisterAudioBufferMetaTypes)


	class QAudioBufferPrivate : public QSharedData
	{
	public:
	QAudioBufferPrivate(QAbstractAudioBuffer *provider)
	: mProvider(provider)
	, mCount(1)
	{
	}

	~QAudioBufferPrivate()
	{
	if (mProvider)
	mProvider->release();
	}

	void ref()
	{
	mCount.ref();
	}

	void deref()
	{
	if (!mCount.deref())
	delete this;
	}

	QAudioBufferPrivate *clone();

	static QAudioBufferPrivate acquire(QAudioBufferPrivate other)
	{
	if (!other)
	return nullptr;

	// Ref the other (if there are extant data() pointers, they will
	// also point here - it's a feature, not a bug, like QByteArray)
	other->ref();
	return other;
	}

	QAbstractAudioBuffer *mProvider;
	QAtomicInt mCount;
	};

	// Private class to go in .cpp file
	class QMemoryAudioBufferProvider : public QAbstractAudioBuffer {
	public:
	QMemoryAudioBufferProvider(const void *data, int frameCount, const QAudioFormat &format, qint64 startTime)
	: mStartTime(startTime)
	, mFrameCount(frameCount)
	, mFormat(format)
	{
	int numBytes = format.bytesForFrames(frameCount);
	if (numBytes > 0) {
	mBuffer = malloc(numBytes);
	if (!mBuffer) {
	// OOM, if that's likely
	mStartTime = -1;
	mFrameCount = 0;
	mFormat = QAudioFormat();
	} else {
	// Allocated, see if we have data to copy
	if (data) {
	memcpy(mBuffer, data, numBytes);
	} else {
	// We have to fill with the zero value..
	switch (format.sampleType()) {
	case QAudioFormat::SignedInt:
	// Signed int means 0x80, 0x8000 is zero
	// XXX this is not right for > 8 bits(0x8080 vs 0x8000)
	memset(mBuffer, 0x80, numBytes);
	break;
	default:
	memset(mBuffer, 0x0, numBytes);
	}
	}
	}
	} else
	mBuffer = nullptr;
	}

	~QMemoryAudioBufferProvider()
	{
	if (mBuffer)
	free(mBuffer);
	}

	void release() override {delete this;}
	QAudioFormat format() const override {return mFormat;}
	qint64 startTime() const override {return mStartTime;}
	int frameCount() const override {return mFrameCount;}

	void *constData() const override {return mBuffer;}

	void *writableData() override {return mBuffer;}
	QAbstractAudioBuffer *clone() const override
	{
	return new QMemoryAudioBufferProvider(mBuffer, mFrameCount, mFormat, mStartTime);
	}

	void *mBuffer;
	qint64 mStartTime;
	int mFrameCount;
	QAudioFormat mFormat;
	};

	QAudioBufferPrivate *QAudioBufferPrivate::clone()
	{
	// We want to create a single bufferprivate with a
	// single qaab
	// This should only be called when the count is > 1
	Q_ASSERT(mCount.loadRelaxed() > 1);

	if (mProvider) {
	QAbstractAudioBuffer *abuf = mProvider->clone();

	if (!abuf) {
	abuf = new QMemoryAudioBufferProvider(mProvider->constData(), mProvider->frameCount(), mProvider->format(), mProvider->startTime());
	}

	if (abuf) {
	return new QAudioBufferPrivate(abuf);
	}
	}

	return nullptr;
	}

	/*!
	\class QAbstractAudioBuffer
	\internal
	*/

	/*!
	\class QAudioBuffer
	\inmodule QtMultimedia
	\ingroup multimedia
	\ingroup multimedia_audio
	\brief The QAudioBuffer class represents a collection of audio samples with a specific format and sample rate.
	*/
	// ^ Mostly useful with probe or decoder

	/*!
	Create a new, empty, invalid buffer.
	*/
	QAudioBuffer::QAudioBuffer()
	: d(nullptr)
	{
	}

	/*!
	\internal
	Create a new audio buffer from the supplied \a provider. This
	constructor is typically only used when handling certain hardware
	or media framework specific buffers, and generally isn't useful
	in application code.
	*/
	QAudioBuffer::QAudioBuffer(QAbstractAudioBuffer *provider)
	: d(new QAudioBufferPrivate(provider))
	{
	}
	/*!
	Creates a new audio buffer from \a other. Generally
	this will have copy-on-write semantics - a copy will
	only be made when it has to be.
	*/
	QAudioBuffer::QAudioBuffer(const QAudioBuffer &other)
	{
	d = QAudioBufferPrivate::acquire(other.d);
	}

	/*!
	Creates a new audio buffer from the supplied \a data, in the
	given \a format. The format will determine how the number
	and sizes of the samples are interpreted from the \a data.

	If the supplied \a data is not an integer multiple of the
	calculated frame size, the excess data will not be used.

	This audio buffer will copy the contents of \a data.

	\a startTime (in microseconds) indicates when this buffer
	starts in the stream.
	If this buffer is not part of a stream, set it to -1.
	*/
	QAudioBuffer::QAudioBuffer(const QByteArray &data, const QAudioFormat &format, qint64 startTime)
	{
	if (format.isValid()) {
	int frameCount = format.framesForBytes(data.size());
	d = new QAudioBufferPrivate(new QMemoryAudioBufferProvider(data.constData(), frameCount, format, startTime));
	} else
	d = nullptr;
	}

	/*!
	Creates a new audio buffer with space for \a numFrames frames of
	the given \a format. The individual samples will be initialized
	to the default for the format.

	\a startTime (in microseconds) indicates when this buffer
	starts in the stream.
	If this buffer is not part of a stream, set it to -1.
	*/
	QAudioBuffer::QAudioBuffer(int numFrames, const QAudioFormat &format, qint64 startTime)
	{
	if (format.isValid())
	d = new QAudioBufferPrivate(new QMemoryAudioBufferProvider(nullptr, numFrames, format, startTime));
	else
	d = nullptr;
	}

	/*!
	Assigns the \a other buffer to this.
	*/
	QAudioBuffer &QAudioBuffer::operator =(const QAudioBuffer &other)
	{
	if (this->d != other.d) {
	if (d)
	d->deref();
	d = QAudioBufferPrivate::acquire(other.d);
	}
	return *this;
	}

	/*!
	Destroys this audio buffer.
	*/
	QAudioBuffer::~QAudioBuffer()
	{
	if (d)
	d->deref();
	}

	/*!
	Returns true if this is a valid buffer. A valid buffer
	has more than zero frames in it and a valid format.
	*/
	bool QAudioBuffer::isValid() const
	{
	if (!d \|\| !d->mProvider)
	return false;
	return d->mProvider->format().isValid() && (d->mProvider->frameCount() > 0);
	}

	/*!
	Returns the \l {QAudioFormat}{format} of this buffer.

	Several properties of this format influence how
	the \l duration() or \l byteCount() are calculated
	from the \l frameCount().
	*/
	QAudioFormat QAudioBuffer::format() const
	{
	if (!isValid())
	return QAudioFormat();
	return d->mProvider->format();
	}

	/*!
	Returns the number of complete audio frames in this buffer.

	An audio frame is an interleaved set of one sample per channel
	for the same instant in time.
	*/
	int QAudioBuffer::frameCount() const
	{
	if (!isValid())
	return 0;
	return d->mProvider->frameCount();
	}

	/*!
	Returns the number of samples in this buffer.

	If the format of this buffer has multiple channels,
	then this count includes all channels. This means
	that a stereo buffer with 1000 samples in total will
	have 500 left samples and 500 right samples (interleaved),
	and this function will return 1000.

	\sa frameCount()
	*/
	int QAudioBuffer::sampleCount() const
	{
	if (!isValid())
	return 0;

	return frameCount() * format().channelCount();
	}

	/*!
	Returns the size of this buffer, in bytes.
	*/
	int QAudioBuffer::byteCount() const
	{
	const QAudioFormat f(format());
	return format().bytesForFrames(frameCount());
	}

	/*!
	Returns the duration of audio in this buffer, in microseconds.

	This depends on the \l format(), and the \l frameCount().
	*/
	qint64 QAudioBuffer::duration() const
	{
	return format().durationForFrames(frameCount());
	}

	/*!
	Returns the time in a stream that this buffer starts at (in microseconds).

	If this buffer is not part of a stream, this will return -1.
	*/
	qint64 QAudioBuffer::startTime() const
	{
	if (!isValid())
	return -1;
	return d->mProvider->startTime();
	}

	/*!
	Returns a pointer to this buffer's data. You can only read it.

	This method is preferred over the const version of \l data() to
	prevent unnecessary copying.

	There is also a templatized version of this constData() function that
	allows you to retrieve a specific type of read-only pointer to
	the data. Note that there is no checking done on the format of
	the audio buffer - this is simply a convenience function.

	\code
	// With a 16bit sample buffer:
	const quint16 *data = buffer->constData<quint16>();
	\endcode

	*/
	const void* QAudioBuffer::constData() const
	{
	if (!isValid())
	return nullptr;
	return d->mProvider->constData();
	}

	/*!
	Returns a pointer to this buffer's data. You can only read it.

	You should use the \l constData() function rather than this
	to prevent accidental deep copying.

	There is also a templatized version of this data() function that
	allows you to retrieve a specific type of read-only pointer to
	the data. Note that there is no checking done on the format of
	the audio buffer - this is simply a convenience function.

	\code
	// With a 16bit sample const buffer:
	const quint16 *data = buffer->data<quint16>();
	\endcode
	*/
	const void* QAudioBuffer::data() const
	{
	if (!isValid())
	return nullptr;
	return d->mProvider->constData();
	}


	/*
	Template data/constData functions caused override problems with qdoc,
	so moved their docs into the non template versions.
	*/

	/*!
	Returns a pointer to this buffer's data. You can modify the
	data through the returned pointer.

	Since QAudioBuffers can share the actual sample data, calling
	this function will result in a deep copy being made if there
	are any other buffers using the sample. You should avoid calling
	this unless you really need to modify the data.

	This pointer will remain valid until the underlying storage is
	detached. In particular, if you obtain a pointer, and then
	copy this audio buffer, changing data through this pointer may
	change both buffer instances. Calling \l data() on either instance
	will again cause a deep copy to be made, which may invalidate
	the pointers returned from this function previously.

	There is also a templatized version of data() allows you to retrieve
	a specific type of pointer to the data. Note that there is no
	checking done on the format of the audio buffer - this is
	simply a convenience function.

	\code
	// With a 16bit sample buffer:
	quint16 *data = buffer->data<quint16>(); // May cause deep copy
	\endcode
	*/
	void *QAudioBuffer::data()
	{
	if (!isValid())
	return nullptr;

	if (d->mCount.loadRelaxed() != 1) {
	// Can't share a writable buffer
	// so we need to detach
	QAudioBufferPrivate *newd = d->clone();

	// This shouldn't happen
	if (!newd)
	return nullptr;

	d->deref();
	d = newd;
	}

	// We're (now) the only user of this qaab, so
	// see if it's writable directly
	void *buffer = d->mProvider->writableData();
	if (buffer) {
	return buffer;
	}

	// Wasn't writable, so turn it into a memory provider
	QAbstractAudioBuffer *memBuffer = new QMemoryAudioBufferProvider(constData(), frameCount(), format(), startTime());

	if (memBuffer) {
	d->mProvider->release();
	d->mCount.storeRelaxed(1);
	d->mProvider = memBuffer;

	return memBuffer->writableData();
	}

	return nullptr;
	}

	// Template helper classes worth documenting

	/*!
	\class QAudioBuffer::StereoFrameDefault
	\internal

	Just a trait class for the default value.
	*/

	/*!
	\class QAudioBuffer::StereoFrame
	\brief The StereoFrame class provides a simple wrapper for a stereo audio frame.
	\inmodule QtMultimedia
	\ingroup multimedia
	\ingroup multimedia_audio

	This templatized structure lets you treat a block of individual samples as an
	interleaved stereo stream frame. This is most useful when used with the templatized
	\l {QAudioBuffer::data()}{data()} functions of QAudioBuffer. Generally the data
	is accessed as a pointer, so no copying should occur.

	There are some predefined instantiations of this template for working with common
	stereo sample depths in a convenient way.

	This frame structure has \e left and \e right members for accessing individual channel data.

	For example:
	\code
	// Assuming 'buffer' is an unsigned 16 bit stereo buffer..
	QAudioBuffer::S16U *frames = buffer->data<QAudioBuffer::S16U>();
	for (int i=0; i < buffer->frameCount(); i++) {
	qSwap(frames[i].left, frames[i].right);
	}
	\endcode

	\sa QAudioBuffer::S8U, QAudioBuffer::S8S, QAudioBuffer::S16S, QAudioBuffer::S16U, QAudioBuffer::S32F
	*/

	/*!
	\fn template <typename T> QAudioBuffer::StereoFrame<T>::StereoFrame()

	Constructs a new frame with the "silent" value for this
	sample format (0 for signed formats and floats, 0x8* for unsigned formats).
	*/

	/*!
	\fn template <typename T> QAudioBuffer::StereoFrame<T>::StereoFrame(T leftSample, T rightSample)

	Constructs a new frame with the supplied \a leftSample and \a rightSample values.
	*/

	/*!
	\fn template <typename T> QAudioBuffer::StereoFrame<T>::operator=(const StereoFrame &other)

	Assigns \a other to this frame.
	*/


	/*!
	\fn template <typename T> QAudioBuffer::StereoFrame<T>::average() const

	Returns the arithmetic average of the left and right samples.
	*/

	/*! \fn template <typename T> QAudioBuffer::StereoFrame<T>::clear()

	Sets the values of this frame to the "silent" value.
	*/

	/*!
	\variable QAudioBuffer::StereoFrame::left
	\brief the left sample
	*/

	/*!
	\variable QAudioBuffer::StereoFrame::right
	\brief the right sample
	*/

	/*!
	\typedef QAudioBuffer::S8U

	This is a predefined specialization for an unsigned stereo 8 bit sample. Each
	channel is an \e {unsigned char}.
	*/
	/*!
	\typedef QAudioBuffer::S8S

	This is a predefined specialization for a signed stereo 8 bit sample. Each
	channel is a \e {signed char}.
	*/
	/*!
	\typedef QAudioBuffer::S16U

	This is a predefined specialization for an unsigned stereo 16 bit sample. Each
	channel is an \e {unsigned short}.
	*/
	/*!
	\typedef QAudioBuffer::S16S

	This is a predefined specialization for a signed stereo 16 bit sample. Each
	channel is a \e {signed short}.
	*/
	/*!
	\typedef QAudioBuffer::S32F

	This is a predefined specialization for an 32 bit float sample. Each
	channel is a \e float.
	*/

	QT_END_NAMESPACE