qt/qtmultimedia/examples/multimedia/audiosource/audiosource.cpp

Revision control

++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
++
++ #include "audiosource.h"
++
++ #include <QAudioDevice>
++ #include <QAudioSource>
++ #include <QDateTime>
++ #include <QDebug>
++ #include <QDir>
++ #include <QLabel>
++ #include <QMessageBox>
++ #include <QPainter>
++ #include <QtEndian>
++
++ #if QT_CONFIG(permissions)
++ # include <QCoreApplication>
++ # include <QPermission>
++ #endif
++
++ namespace {
++
++ using namespace std::chrono_literals;
++ constexpr auto visualizerUpdateInterval = 16ms;
++ constexpr auto recordingUpdateInterval = 100ms;
++ constexpr int volumeSliderMaximum = 100;
++ constexpr int progressBarMaximum = 100;
++
++ float calculateLevel(const char *data, qint64 len, const QAudioFormat &format)
++ {
++ const int channelBytes = format.bytesPerSample();
++ const int sampleBytes = format.bytesPerFrame();
++ Q_ASSERT(format.bytesPerFrame() != 0); // divide by 0
++ const quint64 numSamples = len / sampleBytes;
++
++ float maxValue = 0;
++ const auto *ptr = reinterpret_cast<const unsigned char *>(data);
++
++ for (int i = 0; i < int(numSamples); ++i) {
++ for (int j = 0; j < format.channelCount(); ++j) {
++ float value = format.normalizedSampleValue(ptr);
++
++ maxValue = qMax(value, maxValue);
++ ptr += channelBytes;
++ }
++ }
++ return maxValue;
++ }
++
++ using namespace Qt::Literals::StringLiterals;
++ QString sampleFormatToString(QAudioFormat::SampleFormat f)
++ {
++ switch (f) {
++ case QAudioFormat::UInt8: return u"UInt8"_s;
++ case QAudioFormat::Int16: return u"Int16"_s;
++ case QAudioFormat::Int32: return u"Int32"_s;
++ case QAudioFormat::Float: return u"Float"_s;
++ default: return u"Unknown"_s;
++ }
++ }
++
++ QString audioModeToString(AudioTestMode mode)
++ {
++ switch (mode) {
++ case AudioTestMode::Pull: return u"Pull Mode"_s;
++ case AudioTestMode::Push: return u"Push Mode"_s;
++ case AudioTestMode::Callback: return u"Callback Mode"_s;
++ default: return u"Unknown"_s;
++ }
++ }
++
++ constexpr std::array allSupportedSampleRates{
++ 8'000, 11'025, 12'000, 16'000, 22'050, 24'000, 32'000, 44'100,
++ 48'000, 64'000, 88'200, 96'000, 128'000, 176'400, 192'000,
++ };
++
++ template <typename T>
++ void setCurrentValue(QComboBox *box, const T &value)
++ {
++ int idx = box->findData(QVariant::fromValue(value));
++ if (idx >= 0)
++ box->setCurrentIndex(idx);
++ }
++
++ void syncFormatGui(QComboBox *m_formatBox, QComboBox *m_channelsBox, QComboBox *m_rateBox,
++ const QAudioFormat &format)
++ {
++ setCurrentValue(m_formatBox, format.sampleFormat());
++ setCurrentValue(m_rateBox, format.sampleRate());
++ setCurrentValue(m_channelsBox, format.channelCount());
++ }
++
++ } // namespace
++
++ AudioInfo::AudioInfo(const QAudioFormat &format) : m_format(format) { }
++
++ void AudioInfo::start()
++ {
++ open(QIODevice::WriteOnly);
++ }
++
++ void AudioInfo::stop()
++ {
++ close();
++ }
++
++ qint64 AudioInfo::readData(char * /* data */, qint64 /* maxlen */)
++ {
++ return 0;
++ }
++
++ qint64 AudioInfo::writeData(const char *data, qint64 len)
++ {
++ m_level = calculateLevel(data, len, m_format);
++
++ emit levelChanged(m_level);
++
++ return len;
++ }
++
++ RenderArea::RenderArea(QWidget *parent) : QWidget(parent)
++ {
++ setBackgroundRole(QPalette::Base);
++ setAutoFillBackground(true);
++
++ setMinimumHeight(30);
++ setMinimumWidth(200);
++ }
++
++ void RenderArea::paintEvent(QPaintEvent * /* event */)
++ {
++ QPainter painter(this);
++
++ painter.setPen(Qt::black);
++
++ const QRect frame = painter.viewport() - QMargins(10, 10, 10, 10);
++ painter.drawRect(frame);
++ if (m_level == 0.0)
++ return;
++
++ float remappedLevel = QtAudio::convertVolume(m_level, QtAudio::LinearVolumeScale,
++ QtAudio::LogarithmicVolumeScale);
++
++ const int pos = qRound(qreal(frame.width() - 1) * remappedLevel);
++ painter.fillRect(frame.left() + 1, frame.top() + 1, pos, frame.height() - 1, Qt::red);
++ }
++
++ void RenderArea::setLevel(float value)
++ {
++ m_level = value;
++ update();
++ }
++
++ InputTest::InputTest()
++ : m_devices(new QMediaDevices(this))
++ {
++ init();
++ }
++
++ InputTest::~InputTest()
++ {
++ cleanupAudioSource();
++ }
++
++ void InputTest::initializeWindow()
++ {
++ m_layout = new QVBoxLayout(this);
++
++ m_canvas = new RenderArea(this);
++ m_layout->addWidget(m_canvas);
++
++ m_deviceBox = new QComboBox(this);
++ QAudioDevice defaultDevice = QMediaDevices::defaultAudioInput();
++ for (auto &deviceInfo : QMediaDevices::audioInputs())
++ m_deviceBox->addItem(deviceInfo.description(), QVariant::fromValue(deviceInfo));
++ auto defaultDeviceIndex = m_deviceBox->findData(QVariant::fromValue(defaultDevice));
++ m_deviceBox->setCurrentIndex(defaultDeviceIndex);
++
++ connect(m_deviceBox, &QComboBox::currentIndexChanged, this, &InputTest::deviceChanged);
++ connect(m_devices, &QMediaDevices::audioInputsChanged, this, &InputTest::updateAudioDevices);
++ m_layout->addWidget(m_deviceBox);
++
++ m_modeBox = new QComboBox(this);
++ m_modeBox->addItem(audioModeToString(AudioTestMode::Pull));
++ m_modeBox->addItem(audioModeToString(AudioTestMode::Push));
++ m_modeBox->addItem(audioModeToString(AudioTestMode::Callback));
++ m_modeBox->setCurrentIndex(qToUnderlying(m_mode));
++ connect(m_modeBox, &QComboBox::currentIndexChanged, this, [this](int index) {
++ m_mode = AudioTestMode(index);
++ restartAudioStream(false);
++ });
++ m_layout->addWidget(m_modeBox);
++
++ m_suspendResumeButton = new QPushButton(this);
++ connect(m_suspendResumeButton, &QPushButton::clicked, this, &InputTest::toggleSuspend);
++ m_layout->addWidget(m_suspendResumeButton);
++
++ m_volumeSlider = new QSlider(Qt::Horizontal, this);
++ m_volumeSlider->setRange(0, volumeSliderMaximum);
++ m_volumeSlider->setValue(volumeSliderMaximum);
++ connect(m_volumeSlider, &QSlider::valueChanged, this, &InputTest::sliderChanged);
++ m_layout->addWidget(m_volumeSlider);
++
++ auto *formatBox = new QHBoxLayout;
++
++ // Sample format selector
++ auto *formatLabel = new QLabel(tr("Sample Format:"));
++ m_formatBox = new QComboBox(this);
++
++ // Sample rate selector
++ auto *rateLabel = new QLabel(tr("Sample Rate:"));
++ m_rateBox = new QComboBox(this);
++
++ // Channel count selector
++ auto *chLabel = new QLabel(tr("Channels:"));
++ m_channelsBox = new QComboBox(this);
++
++ for (auto *box : { m_channelsBox, m_rateBox, m_formatBox })
++ connect(box, &QComboBox::activated, this, [this, box]() {
++ formatChanged(box);
++ });
++
++ // add all to the same row
++ const int horizontalSpacing = 12;
++ formatBox->addWidget(formatLabel);
++ formatBox->addWidget(m_formatBox);
++ formatBox->addSpacing(horizontalSpacing);
++ formatBox->addWidget(rateLabel);
++ formatBox->addWidget(m_rateBox);
++ formatBox->addSpacing(horizontalSpacing);
++ formatBox->addWidget(chLabel);
++ formatBox->addWidget(m_channelsBox);
++
++ m_layout->addLayout(formatBox);
++
++ // Native period frame count selector
++ QHBoxLayout *periodLayout = new QHBoxLayout;
++ auto *periodLabel = new QLabel(tr("Period Size:"));
++ m_periodBox = new QComboBox(this);
++ m_periodBox->addItem(tr("Default"), -1);
++ for (int v = 32; v <= 4096; v *= 2)
++ m_periodBox->addItem(QString::number(v), v);
++ connect(m_periodBox, &QComboBox::activated, this, [this]() {
++ restartAudioStream(false);
++ });
++ periodLayout->addWidget(periodLabel);
++ periodLayout->addWidget(m_periodBox);
++ m_layout->addLayout(periodLayout);
++
++ m_recordButton = new QPushButton(tr("Start 5s Recording"), this);
++ connect(m_recordButton, &QPushButton::clicked, this, [this]() {
++ if (m_audioSource && !m_currentDevice.isNull())
++ restartAudioStream(true);
++ });
++ m_layout->addWidget(m_recordButton);
++
++ m_recordProgressBar = new QProgressBar(this);
++ m_recordProgressBar->hide();
++ m_recordProgressBar->setRange(0, progressBarMaximum);
++ m_recordProgressBar->setFormat(tr("Recording... %p%"));
++ m_layout->addWidget(m_recordProgressBar);
++ }
++
++ void InputTest::startAudioSource(const QAudioDevice &device, const QAudioFormat &format)
++ {
++ if (m_audioSource)
++ cleanupAudioSource();
++
++ m_audioSource = std::make_unique<QAudioSource>(device, format);
++ m_audioSource->setNativePeriodFrameCount(m_periodBox->currentData().toInt());
++
++ m_currentDevice = device;
++
++ syncFormatGui(m_formatBox, m_channelsBox, m_rateBox, m_audioSource->format());
++
++ connect(m_audioSource.get(), &QAudioSource::stateChanged, this,
++ [this, device](QAudio::State state) {
++ switch (state) {
++ case QAudio::ActiveState:
++ m_suspendResumeButton->setText(tr("Suspend capture"));
++ return;
++ case QAudio::SuspendedState:
++ m_suspendResumeButton->setText(tr("Resume capture"));
++ return;
++ default:
++ break;
++ }
++
++ const auto err = m_audioSource->error();
++
++ // startup failure (format rejected or device unavailable)
++ if (err == QAudio::OpenError && state == QAudio::StoppedState) {
++ QMessageBox::warning(this, tr("Audio start failed"),
++ tr("Device rejected the format or is unavailable."));
++ return;
++ }
++
++ // runtime I/O or fatal device error (disconnects, etc.)
++ if (err == QAudio::IOError || err == QAudio::FatalError) {
++ if (m_currentDevice == device) {
++ m_currentDevice = {};
++ m_deviceBox->setCurrentIndex(-1);
++ }
++
++ QMessageBox::warning(this, tr("Audio error"), tr("Audio device error."));
++
++ return;
++ }
++ });
++
++ m_audioInfo = std::make_unique<AudioInfo>(format);
++ connect(m_audioInfo.get(), &AudioInfo::levelChanged, m_canvas, &RenderArea::setLevel);
++
++ float initialVolume =
++ QAudio::convertVolume(float(m_audioSource->volume()), QAudio::LinearVolumeScale,
++ QAudio::LogarithmicVolumeScale);
++ m_volumeSlider->setValue(qRound(initialVolume * volumeSliderMaximum));
++
++ m_audioInfo->start();
++ restartAudioStream(false);
++ }
++
++ void InputTest::cleanupAudioSource()
++ {
++ if (m_audioInfo)
++ m_audioInfo->stop();
++
++ if (m_audioSource) {
++ m_audioSource->stop();
++ m_audioSource->disconnect(this);
++ }
++
++ m_audioSource.reset();
++ m_currentDevice = {};
++ }
++
++ void InputTest::initializeErrorWindow()
++ {
++ auto *layout = new QVBoxLayout(this);
++ auto *errorLabel = new QLabel(tr("Microphone permission is not granted!"));
++ errorLabel->setWordWrap(true);
++ errorLabel->setAlignment(Qt::AlignCenter);
++ layout->addWidget(errorLabel);
++ }
++
++ void InputTest::restartAudioStream(bool record)
++ {
++ m_audioSource->stop();
++ m_audioSource->setNativePeriodFrameCount(m_periodBox->currentData().toInt());
++ setRecorder(nullptr); // Stops possible recording
++
++ if (m_callbackVisualizerTimer.isActive())
++ m_callbackVisualizerTimer.stop();
++
++ switch (m_mode) {
++ case AudioTestMode::Pull: {
++ startPullMode(record);
++ break;
++ }
++ case AudioTestMode::Push: {
++ startPushMode(record);
++ break;
++ }
++ case AudioTestMode::Callback: {
++ startCallbackMode(record);
++ break;
++ }
++ default:
++ Q_UNREACHABLE();
++ }
++
++ if (m_audioSource->error() != QAudio::NoError) {
++ QMessageBox::warning(this, tr("Audio start failed"),
++ tr("Device rejected the format or is unavailable."));
++ }
++ }
++
++ void InputTest::timerEvent(QTimerEvent *event)
++ {
++ if (event->timerId() == m_callbackVisualizerTimer.timerId())
++ m_canvas->setLevel(m_level.exchange(0.f));
++ else if (event->timerId() == m_recordingProgressTimer.timerId()) {
++ Q_ASSERT(m_recorder);
++ if (m_recorder->isDone())
++ restartAudioStream(false);
++ else
++ updateRecordingProgress();
++ }
++ }
++
++ template <typename T>
++ void InputTest::processCallback(QSpan<const T> buffer, const QAudioFormat &format) noexcept
++ Q_DECL_NONBLOCKING_FUNCTION
++ {
++ auto *callbackRecorder = static_cast<CallbackRecorder *>(m_recorder.get());
++ if (callbackRecorder)
++ callbackRecorder->writeSpan(as_bytes(buffer));
++
++ float level = calculateLevel(reinterpret_cast<const char *>(buffer.data()), buffer.size_bytes(),
++ format);
++ float lastLevel = m_level.load(std::memory_order_relaxed);
++ while (!m_level.compare_exchange_weak(lastLevel, std::max(level, lastLevel)))
++ ;
++ }
++
++ void InputTest::startPullMode(bool record)
++ {
++ // pull mode: QAudioSource provides a QIODevice to pull from
++ auto *readDevice = m_audioSource->start();
++ if (!readDevice)
++ return;
++
++ if (record)
++ setRecorder(std::make_unique<PullRecorder>(m_audioSource->format(),
++ getRecordingFileName()));
++
++ connect(readDevice, &QIODevice::readyRead, this, [this, readDevice]() {
++ const qint64 maxLength = m_audioSource->bytesAvailable();
++ QByteArray buffer(maxLength, 0);
++ const qint64 bytesRead = readDevice->read(buffer.data(), maxLength);
++ if (bytesRead <= 0)
++ return;
++
++ const float level = calculateLevel(buffer.constData(), bytesRead, m_audioSource->format());
++ m_canvas->setLevel(level);
++
++ auto *pullRecorder = static_cast<PullRecorder *>(m_recorder.get());
++ if (!pullRecorder)
++ return;
++
++ pullRecorder->writeSpan(
++ { reinterpret_cast<const std::byte *>(buffer.constData()), (qsizetype)bytesRead });
++ });
++ }
++
++ void InputTest::startPushMode(bool record)
++ {
++ // push mode: QAudioSource pushes data into QIODevice
++ if (record) {
++ auto pushRecorder = std::make_unique<PushRecorder>(m_audioSource->format(), getRecordingFileName());
++ pushRecorder->open(QIODeviceBase::WriteOnly);
++ m_audioSource->start(pushRecorder.get());
++ setRecorder(std::move(pushRecorder));
++ } else {
++ m_audioSource->start(m_audioInfo.get());
++ }
++ }
++
++ void InputTest::startCallbackMode(bool record)
++ {
++ // callback mode: QAudioSource calls a callback function on audio thread with a buffer to read from
++ if (record)
++ setRecorder(std::make_unique<CallbackRecorder>(m_audioSource->format(),
++ getRecordingFileName()));
++
++ QAudioFormat format = m_audioSource->format();
++ switch (format.sampleFormat()) {
++ case QAudioFormat::UInt8:
++ m_audioSource->start([this, format](QSpan<const uint8_t> buffer) {
++ processCallback(buffer, format);
++ });
++ break;
++ case QAudioFormat::Int16:
++ m_audioSource->start([this, format](QSpan<const int16_t> buffer) {
++ processCallback(buffer, format);
++ });
++ break;
++ case QAudioFormat::Int32:
++ m_audioSource->start([this, format](QSpan<const int32_t> buffer) {
++ processCallback(buffer, format);
++ });
++ break;
++ case QAudioFormat::Float:
++ m_audioSource->start([this, format](QSpan<const float> buffer) {
++ processCallback(buffer, format);
++ });
++ break;
++ default:
++ Q_UNREACHABLE();
++ };
++
++ m_callbackVisualizerTimer.start(visualizerUpdateInterval, Qt::PreciseTimer, this);
++ }
++
++ QString InputTest::getRecordingFileName() const
++ {
++ QDir tempDir(QDir::tempPath());
++ return tempDir.filePath(
++ QStringLiteral("%1-%2-%3.wav")
++ .arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_hh-mm-ss"))
++ .arg(audioModeToString(m_mode))
++ .arg(m_deviceBox->currentText().split(u" "_s).at(0))
++ .replace(u" "_s, u"_"_s));
++ }
++
++ void InputTest::init()
++ {
++ #if QT_CONFIG(permissions)
++ QMicrophonePermission microphonePermission;
++ switch (qApp->checkPermission(microphonePermission)) {
++ case Qt::PermissionStatus::Undetermined:
++ qApp->requestPermission(microphonePermission, this, &InputTest::init);
++ return;
++ case Qt::PermissionStatus::Denied:
++ qWarning("Microphone permission is not granted!");
++ initializeErrorWindow();
++ return;
++ case Qt::PermissionStatus::Granted:
++ break;
++ }
++ #endif
++ initializeWindow();
++
++ deviceChanged(m_deviceBox->currentIndex());
++ }
++
++ void InputTest::toggleSuspend()
++ {
++ // toggle suspend/resume
++ switch (m_audioSource->state()) {
++ case QAudio::SuspendedState:
++ m_audioSource->resume();
++ break;
++ case QAudio::ActiveState:
++ m_audioSource->suspend();
++ break;
++ default:
++ // no-op
++ break;
++ }
++ }
++
++ void InputTest::deviceChanged(int index)
++ {
++ auto device = m_deviceBox->itemData(index).value<QAudioDevice>();
++
++ // clear format selectors
++ m_formatBox->clear();
++ m_channelsBox->clear();
++ m_rateBox->clear();
++
++ // Populate format selectors
++ if (!device.isNull()) {
++ // sample formats
++ const auto formats = device.supportedSampleFormats();
++ for (const QAudioFormat::SampleFormat sf : formats)
++ m_formatBox->addItem(sampleFormatToString(sf), QVariant::fromValue(sf));
++
++ // channels
++ for (int ch = device.minimumChannelCount(); ch <= device.maximumChannelCount(); ++ch)
++ m_channelsBox->addItem(QString::number(ch), ch);
++
++ // populate from the hardcoded list
++ for (int rate : allSupportedSampleRates) {
++ if (rate < device.minimumSampleRate() || rate > device.maximumSampleRate())
++ continue;
++ m_rateBox->addItem(QString::number(rate), rate);
++ }
++ }
++
++ if (device != m_currentDevice) {
++ cleanupAudioSource();
++ if (!device.isNull()) {
++ startAudioSource(m_deviceBox->itemData(index).value<QAudioDevice>(),
++ device.preferredFormat());
++ }
++ }
++ }
++
++ void InputTest::sliderChanged(int value)
++ {
++ float linearVolume =
++ QAudio::convertVolume(float(value) / float(volumeSliderMaximum),
++ QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale);
++
++ m_audioSource->setVolume(linearVolume);
++ }
++
++ void InputTest::updateAudioDevices()
++ {
++ QSignalBlocker blockUpdates(m_deviceBox);
++
++ m_deviceBox->clear();
++
++ const QList<QAudioDevice> devices = QMediaDevices::audioInputs();
++ for (const QAudioDevice &deviceInfo : devices)
++ m_deviceBox->addItem(deviceInfo.description(), QVariant::fromValue(deviceInfo));
++ const int currentDeviceIndex = m_deviceBox->findData(QVariant::fromValue(m_currentDevice));
++ if (currentDeviceIndex != -1) {
++ // select previous device
++ m_deviceBox->setCurrentIndex(currentDeviceIndex);
++ } else {
++ blockUpdates.unblock();
++ // select default device
++ QAudioDevice defaultDevice = QMediaDevices::defaultAudioInput();
++ const int defaultDeviceIndex = m_deviceBox->findData(QVariant::fromValue(defaultDevice));
++ const int currentIndex = m_deviceBox->currentIndex();
++ m_deviceBox->setCurrentIndex(defaultDeviceIndex);
++ if (defaultDeviceIndex == currentIndex) {
++ // device changed, reinitialize audio
++ deviceChanged(defaultDeviceIndex);
++ }
++ }
++ }
++
++ void InputTest::formatChanged(QComboBox *box)
++ {
++ auto device = m_deviceBox->currentData().value<QAudioDevice>();
++ QAudioFormat newFormat = m_audioSource->format();
++
++ if (box == m_formatBox)
++ newFormat.setSampleFormat(QAudioFormat::SampleFormat(box->currentData().toInt()));
++ else if (box == m_rateBox)
++ newFormat.setSampleRate(box->currentData().toInt());
++ else if (box == m_channelsBox)
++ newFormat.setChannelCount(box->currentData().toInt());
++
++ startAudioSource(device, newFormat);
++ }
++
++ void InputTest::updateRecordingProgress()
++ {
++ if (!m_recorder) {
++ // Recording completed
++ m_recordingProgressTimer.stop();
++ } else {
++ m_recordProgressBar->setValue(m_recorder->progress(progressBarMaximum));
++
++ if (!m_recordingProgressTimer.isActive()) {
++ // Recording started
++ m_recordingProgressTimer.start(recordingUpdateInterval, Qt::CoarseTimer, this);
++ }
++ }
++ }
++
++ void InputTest::updateControlsForRecording()
++ {
++ bool isRecording = !!m_recorder;
++
++ if (isRecording) {
++ m_recordButton->hide();
++ m_recordProgressBar->show();
++ } else {
++ m_recordProgressBar->hide();
++ m_recordButton->show();
++ }
++
++ m_channelsBox->setDisabled(isRecording);
++ m_deviceBox->setDisabled(isRecording);
++ m_formatBox->setDisabled(isRecording);
++ m_modeBox->setDisabled(isRecording);
++ m_rateBox->setDisabled(isRecording);
++ }
++
++ void InputTest::setRecorder(std::unique_ptr<AudioRecorder> recorder)
++ {
++ m_recorder = std::move(recorder);
++ updateRecordingProgress();
++ updateControlsForRecording();
++ }
++
++ #include "moc_audiosource.cpp"