MicByteBuffer.h

#pragma once
#include "DLLInfo.h"
#ifdef Q_OS_WINDOWS
#include <QAudioSource>
#include <QAudioFormat>
#include <QMediaDevices>
#include <QIODevice>
#include <QByteArray>
#include <QtGlobal>
namespace NDEVR
{
    class NDEVR_SOUND_MANAGER_API MicByteBuffer final : public QObject
    {
        Q_OBJECT
    public:
        explicit MicByteBuffer(QObject* parent = nullptr)
            : QObject(parent)
        {
            QAudioFormat f;
            f.setSampleRate(16000);
            f.setChannelCount(1);
            f.setSampleFormat(QAudioFormat::Int16);
 
            const QAudioDevice dev = QMediaDevices::defaultAudioInput();
            m_format = dev.preferredFormat();
 
            if (dev.isFormatSupported(f))
                m_format = f;
 
            m_source = new QAudioSource(dev, m_format, this);
            m_source->setBufferSize(4096 * 8);
        }

        ~MicByteBuffer() override
        {
            stop();
        }

        void start()
        {
            if (!m_source)
                return;
 
            if (m_io)
                return;
 
            m_buffer.clear();
            m_io = m_source->start();
            if (!m_io)
                return;
 
            connect(m_io, &QIODevice::readyRead, this, &MicByteBuffer::onReadyRead, Qt::DirectConnection);
        }

        void stop()
        {
            if (!m_source)
                return;
 
            if (m_io)
                disconnect(m_io, nullptr, this, nullptr);
 
            m_source->stop();
            m_io = nullptr;
        }

        const QByteArray& bytes() const
        {
            return m_buffer;
        }

        QByteArray takeBytes()
        {
            QByteArray out = std::move(m_buffer);
            m_buffer.clear();
            return out;
        }

        void clear()
        {
            m_buffer.clear();
        }

        qint64 bytesCaptured() const
        {
            return m_totalBytes;
        }

        QAudioFormat format() const
        {
            return m_format;
        }
 
    signals:
        void bytesAppended(qint64 appendedBytes, qint64 totalBytes);
 
    private slots:
        void onReadyRead()
        {
            if (!m_io)
                return;
 
            const qint64 avail = m_io->bytesAvailable();
            if (avail <= 0)
                return;
 
            m_tmp.resize(int(avail));
            const qint64 got = m_io->read(m_tmp.data(), m_tmp.size());
            if (got <= 0)
                return;
 
            m_buffer.append(m_tmp.constData(), int(got));
            m_totalBytes += got;
 
            emit bytesAppended(got, m_totalBytes);
        }
 
    private:
        QAudioSource* m_source = nullptr;   
        QIODevice* m_io = nullptr;          
        QAudioFormat m_format;              
 
        QByteArray m_buffer;                
        QByteArray m_tmp;                   
        qint64 m_totalBytes = 0;            
    };
}
#endif