input.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2019 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_AFV_AUDIO_AUDIO_INPUT_H
#define SWIFT_CORE_AFV_AUDIO_AUDIO_INPUT_H
 
#include "misc/audio/audiodeviceinfo.h"
#include "sound/codecs/opusencoder.h"
#include "sound/sampleprovider/bufferedwaveprovider.h"
 
#ifdef Q_OS_MAC
#    include "misc/macos/microphoneaccess.h"
#endif
 
#include <QAudioSource>
#include <QString>
 
namespace swift::core::afv::audio
{
    class CAudioInputBuffer : public QIODevice
    {
        Q_OBJECT
 
    public:
        CAudioInputBuffer(QObject *parent);
 
        void start(const QAudioFormat &format);
 
        void stop();
 
        virtual qint64 readData(char *data, qint64 maxlen) override;
 
        virtual qint64 writeData(const char *data, qint64 len) override;
 
    signals:
        void frameAvailable(const QByteArray &frame);
 
    private:
        static constexpr qint64 frameSize = 960;
        QByteArray m_buffer;
        QAudioFormat m_format;
    };
 
    struct OpusDataAvailableArgs
    {
        uint sequenceCounter = 0; 
        QByteArray audio; 
    };
 
    struct InputVolumeStreamArgs
    {
        double PeakRaw = 0.0;
 
        double PeakDB = -1.0 * std::numeric_limits<double>::infinity();
 
        double PeakVU = 0.0;
    };
 
    class CInput : public QObject
    {
        Q_OBJECT
 
    public:
        CInput(int sampleRate, QObject *parent = nullptr);
 
        virtual ~CInput() override { this->stop(); }
 
        int opusBytesEncoded() const { return m_opusBytesEncoded; }
        void setOpusBytesEncoded(int opusBytesEncoded) { m_opusBytesEncoded = opusBytesEncoded; }
 
        double getGainRatio() const { return m_gainRatio; }
        bool setGainRatio(double gainRatio);
        // those used to be the original function names
        // double volume() const { return m_volume; }
        // bool setVolume(double volume);
 
        /* disabled as not needed
        double getDeviceInputVolume() const;
        bool setDeviceInputVolume(double volume);
        */
 
        bool started() const { return m_started; }
 
        void start(const swift::misc::audio::CAudioDeviceInfo &inputDevice);
 
        void stop();
 
        const swift::misc::audio::CAudioDeviceInfo &device() const { return m_device; }
 
    signals:
        void inputVolumeStream(const InputVolumeStreamArgs &args);
 
        void opusDataAvailable(const OpusDataAvailableArgs &args);
 
    private:
        void audioInDataAvailable(const QByteArray &frame);
 
        void initMicrophone();
 
        static constexpr qint64 c_frameSize = 960;
        int m_sampleRate = 0;
 
        swift::sound::codecs::COpusEncoder m_encoder;
        QScopedPointer<QAudioSource> m_audioInput;
        swift::misc::audio::CAudioDeviceInfo m_device;
        QAudioFormat m_inputFormat;
 
        bool m_started = false;
        int m_opusBytesEncoded = 0;
        int m_sampleCount = 0;
        double m_gainRatio = 1.0;
        qint16 m_maxSampleInput = 0.0;
 
        const int SampleCountPerEvent = 4800;
        const double maxDb = 0;
        const double minDb = -40;
 
        uint m_audioSequenceCounter = 0;
        CAudioInputBuffer *m_audioInputBuffer = nullptr;
 
#ifdef Q_OS_MAC
        swift::misc::CMacOSMicrophoneAccess m_micAccess;
        void initMicrophoneMacOS();
#endif
    };
} // namespace swift::core::afv::audio
 
#endif // SWIFT_CORE_AFV_AUDIO_AUDIO_INPUT_H