audiogenerationutils_p.h

Go to the documentation of this file.

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#ifndef AUDIOGENERATIONUTILS_H
#define AUDIOGENERATIONUTILS_H
 
 
//
//  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.
//
// We mean it.
//
 
#include <QAudioFormat>
#include <QAudioBuffer>
#include <chrono>
#include <limits>
 
QT_BEGIN_NAMESPACE
 
inline QByteArray createSineWaveData(const QAudioFormat &format, std::chrono::microseconds duration,
                                     qint32 sampleIndex = 0, qreal frequency = 500,
                                     qreal volume = 0.8)
{
    if (!format.isValid())
        return {};
 
    const qint32 length = format.bytesForDuration(duration.count());
 
    QByteArray data(format.bytesForDuration(duration.count()), Qt::Uninitialized);
    unsigned char *ptr = reinterpret_cast<unsigned char *>(data.data());
    const auto end = ptr + length;
 
    auto writeNextFrame = [&](auto value) {
        Q_ASSERT(sizeof(value) == format.bytesPerSample());
        *reinterpret_cast<decltype(value) *>(ptr) = value;
        ptr += sizeof(value);
    };
 
    for (; ptr < end; ++sampleIndex) {
        const qreal x = sin(2 * M_PI * frequency * sampleIndex / format.sampleRate()) * volume;
        for (int ch = 0; ch < format.channelCount(); ++ch) {
            switch (format.sampleFormat()) {
            case QAudioFormat::UInt8:
                writeNextFrame(static_cast<quint8>(std::round((1.0 + x) / 2 * 255)));
                break;
            case QAudioFormat::Int16:
                writeNextFrame(
                        static_cast<qint16>(std::round(x * std::numeric_limits<qint16>::max())));
                break;
            case QAudioFormat::Int32:
                writeNextFrame(
                        static_cast<qint32>(std::round(x * std::numeric_limits<qint32>::max())));
                break;
            case QAudioFormat::Float:
                writeNextFrame(static_cast<float>(x));
                break;
            case QAudioFormat::Unknown:
            case QAudioFormat::NSampleFormats:
                break;
            }
        }
    }
 
    Q_ASSERT(ptr == end);
 
    return data;
}
 
class AudioGenerator : public QObject
{
    Q_OBJECT
public:
    AudioGenerator()
    {
        m_format.setSampleFormat(QAudioFormat::UInt8);
        m_format.setSampleRate(8000);
        m_format.setChannelConfig(QAudioFormat::ChannelConfigMono);
    }
 
    void setFormat(const QAudioFormat &format)
    { //
        m_format = format;
    }
 
    void setBufferCount(int count)
    { //
        m_maxBufferCount = std::max(count, 1);
    }
 
    void setDuration(std::chrono::microseconds duration)
    { //
        m_duration = duration;
    }
 
    void setFrequency(qreal frequency)
    { //
        m_frequency = frequency;
    }
 
    void emitEmptyBufferOnStop()
    { //
        m_emitEmptyBufferOnStop = true;
    }
 
    QAudioBuffer createAudioBuffer()
    {
        const std::chrono::microseconds bufferDuration = m_duration * (m_bufferIndex + 1) / m_maxBufferCount
                - m_duration * m_bufferIndex / m_maxBufferCount;
        QByteArray data = createSineWaveData(m_format, bufferDuration, m_sampleIndex, m_frequency);
        Q_ASSERT(m_format.bytesPerSample());
        m_sampleIndex += data.size() / m_format.bytesPerSample();
        return QAudioBuffer(data, m_format);
    }
 
signals:
    void done();
    void audioBufferCreated(const QAudioBuffer &buffer);
 
public slots:
    void nextBuffer()
{
        if (m_bufferIndex == m_maxBufferCount) {
            emit done();
            if (m_emitEmptyBufferOnStop)
                emit audioBufferCreated({});
            return;
        }
 
        const QAudioBuffer buffer = createAudioBuffer();
 
        emit audioBufferCreated(buffer);
        ++m_bufferIndex;
    }
 
private:
    int m_maxBufferCount = 1;
    std::chrono::microseconds m_duration{ std::chrono::seconds{ 1 } };
    int m_bufferIndex = 0;
    QAudioFormat m_format;
    bool m_emitEmptyBufferOnStop = false;
    qreal m_frequency = 500.;
    qint32 m_sampleIndex = 0;
};
 
QT_END_NAMESPACE
 
#endif // AUDIOGENERATIONUTILS_H