qt-everywhere-src-5.14.1/qtmultimedia/examples/multimedia/audiorecorder/audiorecorder.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** 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.
 **
 ** BSD License Usage
 ** Alternatively, you may use this file under the terms of the BSD license
 ** as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of The Qt Company Ltd nor the names of its
 **     contributors may be used to endorse or promote products derived
 **     from this software without specific prior written permission.
 **
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "audiorecorder.h"
 #include "audiolevel.h"

 #include "ui_audiorecorder.h"

 #include <QAudioProbe>
 #include <QAudioRecorder>
 #include <QDir>
 #include <QFileDialog>
 #include <QMediaRecorder>
 #include <QStandardPaths>

 static qreal getPeakValue(const QAudioFormat &format);
 static QVector<qreal> getBufferLevels(const QAudioBuffer &buffer);

 template <class T>
 static QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels);

 AudioRecorder::AudioRecorder()
     : ui(new Ui::AudioRecorder)
 {
     ui->setupUi(this);

     m_audioRecorder = new QAudioRecorder(this);
     m_probe = new QAudioProbe(this);
     connect(m_probe, &QAudioProbe::audioBufferProbed,
             this, &AudioRecorder::processBuffer);
     m_probe->setSource(m_audioRecorder);

     //audio devices
     ui->audioDeviceBox->addItem(tr("Default"), QVariant(QString()));
     for (auto &device: m_audioRecorder->audioInputs()) {
         ui->audioDeviceBox->addItem(device, QVariant(device));
     }

     //audio codecs
     ui->audioCodecBox->addItem(tr("Default"), QVariant(QString()));
     for (auto &codecName: m_audioRecorder->supportedAudioCodecs()) {
         ui->audioCodecBox->addItem(codecName, QVariant(codecName));
     }

     //containers
     ui->containerBox->addItem(tr("Default"), QVariant(QString()));
     for (auto &containerName: m_audioRecorder->supportedContainers()) {
         ui->containerBox->addItem(containerName, QVariant(containerName));
     }

     //sample rate
     ui->sampleRateBox->addItem(tr("Default"), QVariant(0));
     for (int sampleRate: m_audioRecorder->supportedAudioSampleRates()) {
         ui->sampleRateBox->addItem(QString::number(sampleRate), QVariant(
                 sampleRate));
     }

     //channels
     ui->channelsBox->addItem(tr("Default"), QVariant(-1));
     ui->channelsBox->addItem(QStringLiteral("1"), QVariant(1));
     ui->channelsBox->addItem(QStringLiteral("2"), QVariant(2));
     ui->channelsBox->addItem(QStringLiteral("4"), QVariant(4));

     //quality
     ui->qualitySlider->setRange(0, int(QMultimedia::VeryHighQuality));
     ui->qualitySlider->setValue(int(QMultimedia::NormalQuality));

     //bitrates:
     ui->bitrateBox->addItem(tr("Default"), QVariant(0));
     ui->bitrateBox->addItem(QStringLiteral("32000"), QVariant(32000));
     ui->bitrateBox->addItem(QStringLiteral("64000"), QVariant(64000));
     ui->bitrateBox->addItem(QStringLiteral("96000"), QVariant(96000));
     ui->bitrateBox->addItem(QStringLiteral("128000"), QVariant(128000));

     connect(m_audioRecorder, &QAudioRecorder::durationChanged, this, &AudioRecorder::updateProgress);
     connect(m_audioRecorder, &QAudioRecorder::statusChanged, this, &AudioRecorder::updateStatus);
     connect(m_audioRecorder, &QAudioRecorder::stateChanged, this, &AudioRecorder::onStateChanged);
     connect(m_audioRecorder, QOverload<QMediaRecorder::Error>::of(&QAudioRecorder::error), this,
             &AudioRecorder::displayErrorMessage);
 }

 void AudioRecorder::updateProgress(qint64 duration)
 {
     if (m_audioRecorder->error() != QMediaRecorder::NoError || duration < 2000)
         return;

     ui->statusbar->showMessage(tr("Recorded %1 sec").arg(duration / 1000));
 }

 void AudioRecorder::updateStatus(QMediaRecorder::Status status)
 {
     QString statusMessage;

     switch (status) {
     case QMediaRecorder::RecordingStatus:
         statusMessage = tr("Recording to %1").arg(m_audioRecorder->actualLocation().toString());
         break;
     case QMediaRecorder::PausedStatus:
         clearAudioLevels();
         statusMessage = tr("Paused");
         break;
     case QMediaRecorder::UnloadedStatus:
     case QMediaRecorder::LoadedStatus:
         clearAudioLevels();
         statusMessage = tr("Stopped");
     default:
         break;
     }

     if (m_audioRecorder->error() == QMediaRecorder::NoError)
         ui->statusbar->showMessage(statusMessage);
 }

 void AudioRecorder::onStateChanged(QMediaRecorder::State state)
 {
     switch (state) {
     case QMediaRecorder::RecordingState:
         ui->recordButton->setText(tr("Stop"));
         ui->pauseButton->setText(tr("Pause"));
         break;
     case QMediaRecorder::PausedState:
         ui->recordButton->setText(tr("Stop"));
         ui->pauseButton->setText(tr("Resume"));
         break;
     case QMediaRecorder::StoppedState:
         ui->recordButton->setText(tr("Record"));
         ui->pauseButton->setText(tr("Pause"));
         break;
     }

     ui->pauseButton->setEnabled(m_audioRecorder->state() != QMediaRecorder::StoppedState);
 }

 static QVariant boxValue(const QComboBox *box)
 {
     int idx = box->currentIndex();
     if (idx == -1)
         return QVariant();

     return box->itemData(idx);
 }

 void AudioRecorder::toggleRecord()
 {
     if (m_audioRecorder->state() == QMediaRecorder::StoppedState) {
         m_audioRecorder->setAudioInput(boxValue(ui->audioDeviceBox).toString());

         QAudioEncoderSettings settings;
         settings.setCodec(boxValue(ui->audioCodecBox).toString());
         settings.setSampleRate(boxValue(ui->sampleRateBox).toInt());
         settings.setBitRate(boxValue(ui->bitrateBox).toInt());
         settings.setChannelCount(boxValue(ui->channelsBox).toInt());
         settings.setQuality(QMultimedia::EncodingQuality(ui->qualitySlider->value()));
         settings.setEncodingMode(ui->constantQualityRadioButton->isChecked() ?
                                  QMultimedia::ConstantQualityEncoding :
                                  QMultimedia::ConstantBitRateEncoding);

         QString container = boxValue(ui->containerBox).toString();

         m_audioRecorder->setEncodingSettings(settings, QVideoEncoderSettings(), container);
         m_audioRecorder->record();
     }
     else {
         m_audioRecorder->stop();
     }
 }

 void AudioRecorder::togglePause()
 {
     if (m_audioRecorder->state() != QMediaRecorder::PausedState)
         m_audioRecorder->pause();
     else
         m_audioRecorder->record();
 }

 void AudioRecorder::setOutputLocation()
 {
 #ifdef Q_OS_WINRT
     // UWP does not allow to store outside the sandbox
     const QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
     if (!QDir().mkpath(cacheDir)) {
         qWarning() << "Failed to create cache directory";
         return;
     }
     QString fileName = cacheDir + QLatin1String("/output.wav");
 #else
     QString fileName = QFileDialog::getSaveFileName();
 #endif
     m_audioRecorder->setOutputLocation(QUrl::fromLocalFile(fileName));
     m_outputLocationSet = true;
 }

 void AudioRecorder::displayErrorMessage()
 {
     ui->statusbar->showMessage(m_audioRecorder->errorString());
 }

 void AudioRecorder::clearAudioLevels()
 {
     for (int i = 0; i < m_audioLevels.size(); ++i)
         m_audioLevels.at(i)->setLevel(0);
 }

 // This function returns the maximum possible sample value for a given audio format
 qreal getPeakValue(const QAudioFormat& format)
 {
     // Note: Only the most common sample formats are supported
     if (!format.isValid())
         return qreal(0);

     if (format.codec() != "audio/pcm")
         return qreal(0);

     switch (format.sampleType()) {
     case QAudioFormat::Unknown:
         break;
     case QAudioFormat::Float:
         if (format.sampleSize() != 32) // other sample formats are not supported
             return qreal(0);
         return qreal(1.00003);
     case QAudioFormat::SignedInt:
         if (format.sampleSize() == 32)
             return qreal(INT_MAX);
         if (format.sampleSize() == 16)
             return qreal(SHRT_MAX);
         if (format.sampleSize() == 8)
             return qreal(CHAR_MAX);
         break;
     case QAudioFormat::UnSignedInt:
         if (format.sampleSize() == 32)
             return qreal(UINT_MAX);
         if (format.sampleSize() == 16)
             return qreal(USHRT_MAX);
         if (format.sampleSize() == 8)
             return qreal(UCHAR_MAX);
         break;
     }

     return qreal(0);
 }

 // returns the audio level for each channel
 QVector<qreal> getBufferLevels(const QAudioBuffer& buffer)
 {
     QVector<qreal> values;

     if (!buffer.format().isValid() || buffer.format().byteOrder() != QAudioFormat::LittleEndian)
         return values;

     if (buffer.format().codec() != "audio/pcm")
         return values;

     int channelCount = buffer.format().channelCount();
     values.fill(0, channelCount);
     qreal peak_value = getPeakValue(buffer.format());
     if (qFuzzyCompare(peak_value, qreal(0)))
         return values;

     switch (buffer.format().sampleType()) {
     case QAudioFormat::Unknown:
     case QAudioFormat::UnSignedInt:
         if (buffer.format().sampleSize() == 32)
             values = getBufferLevels(buffer.constData<quint32>(), buffer.frameCount(), channelCount);
         if (buffer.format().sampleSize() == 16)
             values = getBufferLevels(buffer.constData<quint16>(), buffer.frameCount(), channelCount);
         if (buffer.format().sampleSize() == 8)
             values = getBufferLevels(buffer.constData<quint8>(), buffer.frameCount(), channelCount);
         for (int i = 0; i < values.size(); ++i)
             values[i] = qAbs(values.at(i) - peak_value / 2) / (peak_value / 2);
         break;
     case QAudioFormat::Float:
         if (buffer.format().sampleSize() == 32) {
             values = getBufferLevels(buffer.constData<float>(), buffer.frameCount(), channelCount);
             for (int i = 0; i < values.size(); ++i)
                 values[i] /= peak_value;
         }
         break;
     case QAudioFormat::SignedInt:
         if (buffer.format().sampleSize() == 32)
             values = getBufferLevels(buffer.constData<qint32>(), buffer.frameCount(), channelCount);
         if (buffer.format().sampleSize() == 16)
             values = getBufferLevels(buffer.constData<qint16>(), buffer.frameCount(), channelCount);
         if (buffer.format().sampleSize() == 8)
             values = getBufferLevels(buffer.constData<qint8>(), buffer.frameCount(), channelCount);
         for (int i = 0; i < values.size(); ++i)
             values[i] /= peak_value;
         break;
     }

     return values;
 }

 template <class T>
 QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels)
 {
     QVector<qreal> max_values;
     max_values.fill(0, channels);

     for (int i = 0; i < frames; ++i) {
         for (int j = 0; j < channels; ++j) {
             qreal value = qAbs(qreal(buffer[i * channels + j]));
             if (value > max_values.at(j))
                 max_values.replace(j, value);
         }
     }

     return max_values;
 }

 void AudioRecorder::processBuffer(const QAudioBuffer& buffer)
 {
     if (m_audioLevels.count() != buffer.format().channelCount()) {
         qDeleteAll(m_audioLevels);
         m_audioLevels.clear();
         for (int i = 0; i < buffer.format().channelCount(); ++i) {
             AudioLevel *level = new AudioLevel(ui->centralwidget);
             m_audioLevels.append(level);
             ui->levelsLayout->addWidget(level);
         }
     }

     QVector<qreal> levels = getBufferLevels(buffer);
     for (int i = 0; i < levels.count(); ++i)
         m_audioLevels.at(i)->setLevel(levels.at(i));
 }
	/****************************************************************************
	**
	** Copyright (C) 2017 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the examples of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:BSD$
	** 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.
	**
	** BSD License Usage
	** Alternatively, you may use this file under the terms of the BSD license
	** as follows:
	**
	** "Redistribution and use in source and binary forms, with or without
	** modification, are permitted provided that the following conditions are
	** met:
	** * Redistributions of source code must retain the above copyright
	** notice, this list of conditions and the following disclaimer.
	** * Redistributions in binary form must reproduce the above copyright
	** notice, this list of conditions and the following disclaimer in
	** the documentation and/or other materials provided with the
	** distribution.
	** * Neither the name of The Qt Company Ltd nor the names of its
	** contributors may be used to endorse or promote products derived
	** from this software without specific prior written permission.
	**
	**
	** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "audiorecorder.h"
	#include "audiolevel.h"

	#include "ui_audiorecorder.h"

	#include <QAudioProbe>
	#include <QAudioRecorder>
	#include <QDir>
	#include <QFileDialog>
	#include <QMediaRecorder>
	#include <QStandardPaths>

	static qreal getPeakValue(const QAudioFormat &format);
	static QVector<qreal> getBufferLevels(const QAudioBuffer &buffer);

	template <class T>
	static QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels);

	AudioRecorder::AudioRecorder()
	: ui(new Ui::AudioRecorder)
	{
	ui->setupUi(this);

	m_audioRecorder = new QAudioRecorder(this);
	m_probe = new QAudioProbe(this);
	connect(m_probe, &QAudioProbe::audioBufferProbed,
	this, &AudioRecorder::processBuffer);
	m_probe->setSource(m_audioRecorder);

	//audio devices
	ui->audioDeviceBox->addItem(tr("Default"), QVariant(QString()));
	for (auto &device: m_audioRecorder->audioInputs()) {
	ui->audioDeviceBox->addItem(device, QVariant(device));
	}

	//audio codecs
	ui->audioCodecBox->addItem(tr("Default"), QVariant(QString()));
	for (auto &codecName: m_audioRecorder->supportedAudioCodecs()) {
	ui->audioCodecBox->addItem(codecName, QVariant(codecName));
	}

	//containers
	ui->containerBox->addItem(tr("Default"), QVariant(QString()));
	for (auto &containerName: m_audioRecorder->supportedContainers()) {
	ui->containerBox->addItem(containerName, QVariant(containerName));
	}

	//sample rate
	ui->sampleRateBox->addItem(tr("Default"), QVariant(0));
	for (int sampleRate: m_audioRecorder->supportedAudioSampleRates()) {
	ui->sampleRateBox->addItem(QString::number(sampleRate), QVariant(
	sampleRate));
	}

	//channels
	ui->channelsBox->addItem(tr("Default"), QVariant(-1));
	ui->channelsBox->addItem(QStringLiteral("1"), QVariant(1));
	ui->channelsBox->addItem(QStringLiteral("2"), QVariant(2));
	ui->channelsBox->addItem(QStringLiteral("4"), QVariant(4));

	//quality
	ui->qualitySlider->setRange(0, int(QMultimedia::VeryHighQuality));
	ui->qualitySlider->setValue(int(QMultimedia::NormalQuality));

	//bitrates:
	ui->bitrateBox->addItem(tr("Default"), QVariant(0));
	ui->bitrateBox->addItem(QStringLiteral("32000"), QVariant(32000));
	ui->bitrateBox->addItem(QStringLiteral("64000"), QVariant(64000));
	ui->bitrateBox->addItem(QStringLiteral("96000"), QVariant(96000));
	ui->bitrateBox->addItem(QStringLiteral("128000"), QVariant(128000));

	connect(m_audioRecorder, &QAudioRecorder::durationChanged, this, &AudioRecorder::updateProgress);
	connect(m_audioRecorder, &QAudioRecorder::statusChanged, this, &AudioRecorder::updateStatus);
	connect(m_audioRecorder, &QAudioRecorder::stateChanged, this, &AudioRecorder::onStateChanged);
	connect(m_audioRecorder, QOverload<QMediaRecorder::Error>::of(&QAudioRecorder::error), this,
	&AudioRecorder::displayErrorMessage);
	}

	void AudioRecorder::updateProgress(qint64 duration)
	{
	if (m_audioRecorder->error() != QMediaRecorder::NoError \|\| duration < 2000)
	return;

	ui->statusbar->showMessage(tr("Recorded %1 sec").arg(duration / 1000));
	}

	void AudioRecorder::updateStatus(QMediaRecorder::Status status)
	{
	QString statusMessage;

	switch (status) {
	case QMediaRecorder::RecordingStatus:
	statusMessage = tr("Recording to %1").arg(m_audioRecorder->actualLocation().toString());
	break;
	case QMediaRecorder::PausedStatus:
	clearAudioLevels();
	statusMessage = tr("Paused");
	break;
	case QMediaRecorder::UnloadedStatus:
	case QMediaRecorder::LoadedStatus:
	clearAudioLevels();
	statusMessage = tr("Stopped");
	default:
	break;
	}

	if (m_audioRecorder->error() == QMediaRecorder::NoError)
	ui->statusbar->showMessage(statusMessage);
	}

	void AudioRecorder::onStateChanged(QMediaRecorder::State state)
	{
	switch (state) {
	case QMediaRecorder::RecordingState:
	ui->recordButton->setText(tr("Stop"));
	ui->pauseButton->setText(tr("Pause"));
	break;
	case QMediaRecorder::PausedState:
	ui->recordButton->setText(tr("Stop"));
	ui->pauseButton->setText(tr("Resume"));
	break;
	case QMediaRecorder::StoppedState:
	ui->recordButton->setText(tr("Record"));
	ui->pauseButton->setText(tr("Pause"));
	break;
	}

	ui->pauseButton->setEnabled(m_audioRecorder->state() != QMediaRecorder::StoppedState);
	}

	static QVariant boxValue(const QComboBox *box)
	{
	int idx = box->currentIndex();
	if (idx == -1)
	return QVariant();

	return box->itemData(idx);
	}

	void AudioRecorder::toggleRecord()
	{
	if (m_audioRecorder->state() == QMediaRecorder::StoppedState) {
	m_audioRecorder->setAudioInput(boxValue(ui->audioDeviceBox).toString());

	QAudioEncoderSettings settings;
	settings.setCodec(boxValue(ui->audioCodecBox).toString());
	settings.setSampleRate(boxValue(ui->sampleRateBox).toInt());
	settings.setBitRate(boxValue(ui->bitrateBox).toInt());
	settings.setChannelCount(boxValue(ui->channelsBox).toInt());
	settings.setQuality(QMultimedia::EncodingQuality(ui->qualitySlider->value()));
	settings.setEncodingMode(ui->constantQualityRadioButton->isChecked() ?
	QMultimedia::ConstantQualityEncoding :
	QMultimedia::ConstantBitRateEncoding);

	QString container = boxValue(ui->containerBox).toString();

	m_audioRecorder->setEncodingSettings(settings, QVideoEncoderSettings(), container);
	m_audioRecorder->record();
	}
	else {
	m_audioRecorder->stop();
	}
	}

	void AudioRecorder::togglePause()
	{
	if (m_audioRecorder->state() != QMediaRecorder::PausedState)
	m_audioRecorder->pause();
	else
	m_audioRecorder->record();
	}

	void AudioRecorder::setOutputLocation()
	{
	#ifdef Q_OS_WINRT
	// UWP does not allow to store outside the sandbox
	const QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
	if (!QDir().mkpath(cacheDir)) {
	qWarning() << "Failed to create cache directory";
	return;
	}
	QString fileName = cacheDir + QLatin1String("/output.wav");
	#else
	QString fileName = QFileDialog::getSaveFileName();
	#endif
	m_audioRecorder->setOutputLocation(QUrl::fromLocalFile(fileName));
	m_outputLocationSet = true;
	}

	void AudioRecorder::displayErrorMessage()
	{
	ui->statusbar->showMessage(m_audioRecorder->errorString());
	}

	void AudioRecorder::clearAudioLevels()
	{
	for (int i = 0; i < m_audioLevels.size(); ++i)
	m_audioLevels.at(i)->setLevel(0);
	}

	// This function returns the maximum possible sample value for a given audio format
	qreal getPeakValue(const QAudioFormat& format)
	{
	// Note: Only the most common sample formats are supported
	if (!format.isValid())
	return qreal(0);

	if (format.codec() != "audio/pcm")
	return qreal(0);

	switch (format.sampleType()) {
	case QAudioFormat::Unknown:
	break;
	case QAudioFormat::Float:
	if (format.sampleSize() != 32) // other sample formats are not supported
	return qreal(0);
	return qreal(1.00003);
	case QAudioFormat::SignedInt:
	if (format.sampleSize() == 32)
	return qreal(INT_MAX);
	if (format.sampleSize() == 16)
	return qreal(SHRT_MAX);
	if (format.sampleSize() == 8)
	return qreal(CHAR_MAX);
	break;
	case QAudioFormat::UnSignedInt:
	if (format.sampleSize() == 32)
	return qreal(UINT_MAX);
	if (format.sampleSize() == 16)
	return qreal(USHRT_MAX);
	if (format.sampleSize() == 8)
	return qreal(UCHAR_MAX);
	break;
	}

	return qreal(0);
	}

	// returns the audio level for each channel
	QVector<qreal> getBufferLevels(const QAudioBuffer& buffer)
	{
	QVector<qreal> values;

	if (!buffer.format().isValid() \|\| buffer.format().byteOrder() != QAudioFormat::LittleEndian)
	return values;

	if (buffer.format().codec() != "audio/pcm")
	return values;

	int channelCount = buffer.format().channelCount();
	values.fill(0, channelCount);
	qreal peak_value = getPeakValue(buffer.format());
	if (qFuzzyCompare(peak_value, qreal(0)))
	return values;

	switch (buffer.format().sampleType()) {
	case QAudioFormat::Unknown:
	case QAudioFormat::UnSignedInt:
	if (buffer.format().sampleSize() == 32)
	values = getBufferLevels(buffer.constData<quint32>(), buffer.frameCount(), channelCount);
	if (buffer.format().sampleSize() == 16)
	values = getBufferLevels(buffer.constData<quint16>(), buffer.frameCount(), channelCount);
	if (buffer.format().sampleSize() == 8)
	values = getBufferLevels(buffer.constData<quint8>(), buffer.frameCount(), channelCount);
	for (int i = 0; i < values.size(); ++i)
	values[i] = qAbs(values.at(i) - peak_value / 2) / (peak_value / 2);
	break;
	case QAudioFormat::Float:
	if (buffer.format().sampleSize() == 32) {
	values = getBufferLevels(buffer.constData<float>(), buffer.frameCount(), channelCount);
	for (int i = 0; i < values.size(); ++i)
	values[i] /= peak_value;
	}
	break;
	case QAudioFormat::SignedInt:
	if (buffer.format().sampleSize() == 32)
	values = getBufferLevels(buffer.constData<qint32>(), buffer.frameCount(), channelCount);
	if (buffer.format().sampleSize() == 16)
	values = getBufferLevels(buffer.constData<qint16>(), buffer.frameCount(), channelCount);
	if (buffer.format().sampleSize() == 8)
	values = getBufferLevels(buffer.constData<qint8>(), buffer.frameCount(), channelCount);
	for (int i = 0; i < values.size(); ++i)
	values[i] /= peak_value;
	break;
	}

	return values;
	}

	template <class T>
	QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels)
	{
	QVector<qreal> max_values;
	max_values.fill(0, channels);

	for (int i = 0; i < frames; ++i) {
	for (int j = 0; j < channels; ++j) {
	qreal value = qAbs(qreal(buffer[i * channels + j]));
	if (value > max_values.at(j))
	max_values.replace(j, value);
	}
	}

	return max_values;
	}

	void AudioRecorder::processBuffer(const QAudioBuffer& buffer)
	{
	if (m_audioLevels.count() != buffer.format().channelCount()) {
	qDeleteAll(m_audioLevels);
	m_audioLevels.clear();
	for (int i = 0; i < buffer.format().channelCount(); ++i) {
	AudioLevel *level = new AudioLevel(ui->centralwidget);
	m_audioLevels.append(level);
	ui->levelsLayout->addWidget(level);
	}
	}

	QVector<qreal> levels = getBufferLevels(buffer);
	for (int i = 0; i < levels.count(); ++i)
	m_audioLevels.at(i)->setLevel(levels.at(i));
	}