audiosink.hpp

浏览该文件的文档.

#pragma once
 
#include "portaudio.h"
#include "ponyplayer.h"
#include <utility>
#include <vector>
#include <QBuffer>
#include <QDebug>
#include "pa_ringbuffer.h"
#include "pa_util.h"
#include "readerwriterqueue.h"
#include "sonic.h"
#include "audioformat.hpp"
#include "private/hotplug.hpp"
#include "ponyplayer.h"
#include <mutex>
#include <shared_mutex>
 
enum class PlaybackState {
    PLAYING, 
    STOPPED, 
    PAUSED,  
};
 
#define ASSERT_PA_OK(err, message) if ((err) != paNoError) { \
qWarning() << "Error" << Pa_GetErrorText(err); \
ILLEGAL_STATE(message); \
}
 
class PonyAudioSink : public QObject {
    Q_OBJECT
private:
 
    PaStream *m_stream{};
    PaStreamParameters *param{};
    qreal m_volume, m_pitch;
    PlaybackState m_state;
    std::atomic<bool> m_pauseRequested = false; // 当播放完缓存的音频后停止
    HotPlugDetector *hotPlugDetector;
    QList<QString> devicesList;
    QString selectedOutputDevice;
    inline static std::mutex paStreamLock;
    inline static std::atomic_bool paInitialized = false;
 
    PonyAudioFormat m_format;
    PonyAudioFormat m_deviceFormat;
    size_t m_bufferMaxBytes;
    size_t m_sonicBufferMaxBytes;
    qreal m_speedFactor;
    PaUtilRingBuffer m_ringBuffer{};
    std::byte *m_ringBufferData;
    moodycamel::ReaderWriterQueue<AudioDataInfo> dataInfoQueue;
 
    sonicStream sonStream;
    std::byte *sonicBuffer = nullptr;
 
    PaTime m_startPoint = 0.0;
    std::atomic<int64_t> m_dataWritten = 0;
    std::atomic<int64_t> m_dataLastWrote = 0;
 
 
    std::atomic<bool> m_blockingState = false;
    std::mutex m_waitCompleteMutex;
    std::condition_variable m_waitCompleteCond;
 
    void m_paStreamFinishedCallback() {
        qDebug() << "Stream finished callback.";
        m_state = PlaybackState::PAUSED;
        if (m_state == PlaybackState::PLAYING) {
            emit resourceInsufficient();
        }
        m_waitCompleteCond.notify_all();
        emit stateChanged();
 
    }
 
    int m_paCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer,
                     const PaStreamCallbackTimeInfo *timeInfo) {
        ring_buffer_size_t bytesAvailCount = PaUtil_GetRingBufferReadAvailable(&m_ringBuffer);
        auto bytesNeeded = static_cast<ring_buffer_size_t>(framesPerBuffer *
                                                           static_cast<unsigned long>(m_format.getBytesPerSampleChannels()));
        if (m_blockingState) {
            memset(outputBuffer, 0, static_cast<size_t>(bytesNeeded));
        } else if (bytesAvailCount == 0) {
            memset(outputBuffer, 0, static_cast<size_t>(bytesNeeded));
            if (m_pauseRequested) {
                return paComplete;
            } else {
                qWarning() << "paAbort bytesAvailCount == 0";
            }
        } else {
            ring_buffer_size_t timeAlignedByteWritten = 0; // 透明化加速的影响，表示在1x速度下，理应有多少个Byte被写入
            ring_buffer_size_t byteToBeWritten = std::min(bytesNeeded, bytesAvailCount); // 实际要往PortAudio的Buffer里写多少Byte
            ring_buffer_size_t byteRemainToAlign = byteToBeWritten; // 当前还需要处理多少个timeAlignedByteWritten
            while (byteRemainToAlign) {
                auto *audioDataInfo = dataInfoQueue.peek();
                if (audioDataInfo->processedLength < byteRemainToAlign) {
                    timeAlignedByteWritten += audioDataInfo->origLength;
                    byteRemainToAlign -= audioDataInfo->processedLength;
                    dataInfoQueue.pop();
                } else {
                    ring_buffer_size_t origLengthReduced = std::max(static_cast<ring_buffer_size_t>(1),
                                                                    static_cast<ring_buffer_size_t>(
                                                                            static_cast<double>(byteRemainToAlign) *
                                                                            audioDataInfo->speedUpRate));
                    audioDataInfo->processedLength -= static_cast<qint32>(byteRemainToAlign);
                    audioDataInfo->origLength -= static_cast<qint32>(origLengthReduced);
                    timeAlignedByteWritten += origLengthReduced;
                    byteRemainToAlign = 0;
                }
            }
            if (bytesNeeded > bytesAvailCount) {
                qWarning() << "paAbort bytesAvailCount < bytesNeeded";
                PaUtil_ReadRingBuffer(&m_ringBuffer, outputBuffer, bytesAvailCount);
                memset(static_cast<std::byte *>(outputBuffer) + byteToBeWritten, 0,
                       static_cast<size_t>(bytesNeeded - byteToBeWritten));
            } else {
                PaUtil_ReadRingBuffer(&m_ringBuffer, outputBuffer, byteToBeWritten);
            }
            m_dataWritten += timeAlignedByteWritten;
            m_dataLastWrote = timeAlignedByteWritten;
        }
        return paContinue;
    }
 
    PaError startStreamSafe() {
        PaError err = Pa_StopStream(m_stream);
        if (err != paStreamIsStopped && err != paNoError) {
            return err;
        }
        return Pa_StartStream(m_stream);
    }
 
 
    static void printError(PaError error) {
        qDebug() << "Error" << Pa_GetErrorText(error);
    }
 
    PaDeviceIndex getCurrentOutputDeviceIndex() {
        int deviceCount = Pa_GetDeviceCount();
        for (auto index = 0; index < deviceCount; index++) {
            auto *device = Pa_GetDeviceInfo(index);
            if (strcmp(device->name, selectedOutputDevice.toStdString().data()) == 0 && device->maxOutputChannels > 0) {
                return index;
            }
        }
        return Pa_GetDefaultOutputDevice();
    }
 
    // this should be guarded by paStreamLock
    void initializeStream() {
        if (!paInitialized) {
            Pa_Initialize();
            paInitialized = true;
            qDebug() << "Initialize PonyAudioSink backend.";
        }
        param = new PaStreamParameters;
        if (selectedOutputDevice.isNull()) {
            _getDeviceList();
            selectedOutputDevice = Pa_GetDeviceInfo(Pa_GetDefaultOutputDevice())->name;
        }
        param->device = getCurrentOutputDeviceIndex();
        selectedOutputDevice = Pa_GetDeviceInfo(param->device)->name;
        param->channelCount = m_format.getChannelCount();
        if (param->device == paNoDevice)
            ILLEGAL_STATE("no audio device!");
        param->channelCount = m_format.getChannelCount();
        param->sampleFormat = m_format.getSampleFormatForPA();
        param->suggestedLatency = Pa_GetDeviceInfo(param->device)->defaultLowOutputLatency;
        param->hostApiSpecificStreamInfo = nullptr;
        ASSERT_PA_OK(
                Pa_OpenStream(&m_stream, nullptr, param, m_format.getSampleRate(), paFramesPerBufferUnspecified,
                              paClipOff,
                              [](
                                      const void *inputBuffer,
                                      void *outputBuffer,
                                      unsigned long framesPerBuffer,
                                      const PaStreamCallbackTimeInfo *timeInfo,
                                      PaStreamCallbackFlags statusFlags,
                                      void *userData
                              ) {
                                  return static_cast<PonyAudioSink *>(userData)->m_paCallback(inputBuffer, outputBuffer,
                                                                                              framesPerBuffer,
                                                                                              timeInfo);
                              }, this),
                "Can not open audio stream!"
        )
        const PaStreamInfo *info = Pa_GetStreamInfo(m_stream);
        m_deviceFormat = PonyAudioFormat(PonyPlayer::Int16, static_cast<int>(info->sampleRate),
                                         param->channelCount);
        ASSERT_PA_OK(Pa_SetStreamFinishedCallback(m_stream, [](void *userData) {
            static_cast<PonyAudioSink *>(userData)->m_paStreamFinishedCallback();
        }), "Can not set stream callback!")
 
    }
 
    QString stateToStr() {
        switch (m_state) {
            case PlaybackState::PLAYING:
                return "PLAYING";
            case PlaybackState::PAUSED:
                return "PAUSED";
            case PlaybackState::STOPPED:
                return "STOPPED";
        }
        return "UNKNOWN";
    }
 
    static unsigned nextPowerOf2(unsigned val) {
        val--;
        val = (val >> 1) | val;
        val = (val >> 2) | val;
        val = (val >> 4) | val;
        val = (val >> 8) | val;
        val = (val >> 16) | val;
        return ++val;
    }
 
 
 
public:
    constexpr const static qreal MAX_SPEED_FACTOR = 4;
 
    explicit PonyAudioSink(PonyAudioFormat format) : m_volume(0.5), m_pitch(1.0), m_state(PlaybackState::STOPPED),
                                            m_format(std::move(format)),
                                            m_deviceFormat(PonyPlayer::Unknown, 0, 0), m_speedFactor(1.0) {
 
 
        paStreamLock.lock();
        initializeStream();
        paStreamLock.unlock();
        m_bufferMaxBytes = nextPowerOf2(static_cast<unsigned>(m_format.suggestedRingBuffer(MAX_SPEED_FACTOR)));
        m_sonicBufferMaxBytes = m_bufferMaxBytes * 4;
        m_ringBufferData = static_cast<std::byte *>(PaUtil_AllocateMemory(static_cast<long>(m_bufferMaxBytes)));
        if (PaUtil_InitializeRingBuffer(&m_ringBuffer,
                                        sizeof(std::byte),
                                        static_cast<ring_buffer_size_t>(m_bufferMaxBytes),
                                        m_ringBufferData) < 0)
            throw std::runtime_error("can not initialize ring buffer!");
        sonicBuffer = new std::byte[m_sonicBufferMaxBytes];
        sonStream = sonicCreateStream(m_format.getSampleRate(), m_format.getChannelCount());
        sonicSetChordPitch(sonStream, 1);
        sonicSetSpeed(sonStream, static_cast<float>(m_speedFactor));
        // HotPlugDetector should be created after PA stream open
        hotPlugDetector = new HotPlugDetector(this);
        connect(hotPlugDetector, &HotPlugDetector::audioOutputsChanged, this,
                &PonyAudioSink::onAudioOutputDevicesChanged);
    }
 
    ~PonyAudioSink() override {
        std::lock_guard lock(paStreamLock);
        m_state = PlaybackState::STOPPED;
        PaError err = Pa_CloseStream(m_stream);
        m_stream = nullptr;
        if (err != paNoError) {
            qWarning() << "Error at Destroying PonyAudioSink" << Pa_GetErrorText(err);
        }
    }
 
    void start() {
        std::lock_guard lock(paStreamLock);
        m_pauseRequested = false;
        qDebug() << "Audio start.";
        if (m_state == PlaybackState::PLAYING) {
            qDebug() << "AudioSink already started.";
            return;
        }
        PaError err = startStreamSafe();
        if (err != paNoError) {
            qWarning() << "Error at starting stream:" << Pa_GetErrorText(err);
            ILLEGAL_STATE("Can not start stream!.");
        }
        m_state = PlaybackState::PLAYING;
        qDebug() << "Pa stream started";
 
        emit stateChanged();
    }
 
    void pause() {
        std::lock_guard lock(paStreamLock);
        qDebug() << "Audio requesting pause. Current state is " << stateToStr();
        if (m_state == PlaybackState::PLAYING) {
            Pa_StopStream(m_stream);
            qDebug() << "Stream Stopped";
            m_state = PlaybackState::PAUSED;
        } else if (m_state == PlaybackState::STOPPED) {
            // ignore
        } else {
            qWarning() << "AudioSink already paused.";
        }
    }
 
    void waitComplete() {
        m_pauseRequested = true;
        std::unique_lock lock(m_waitCompleteMutex);
        m_waitCompleteCond.wait(lock);
    }
 
    void stop() {
        std::lock_guard lock(paStreamLock);
        qDebug() << "Audio stateStop.";
        if (m_state == PlaybackState::PLAYING || m_state == PlaybackState::PAUSED) {
            Pa_AbortStream(m_stream);
            m_state = PlaybackState::STOPPED;
        } else {
            qWarning() << "AudioSink already stopped.";
        }
    }
 
    void setBlockState(bool state) {
        m_blockingState = state;
    }
 
    bool isBlock() {
        return m_blockingState;
    }
 
    [[nodiscard]] PlaybackState state() const {
        return m_state;
    }
 
    [[nodiscard]] int64_t freeByte() const {
        return static_cast<int64_t>(PaUtil_GetRingBufferWriteAvailable(&m_ringBuffer))
               - static_cast<int64_t>((MAX_SPEED_FACTOR - m_speedFactor) * static_cast<qreal>(m_bufferMaxBytes) /
                                      MAX_SPEED_FACTOR);
    }
 
    bool write(const char *buf, qint32 origLen) {
        int len = 0;
        if (m_format.getSampleFormat() != PonyPlayer::Int16) {
            throw std::runtime_error("Only support Int16!");
        }
        if (origLen % m_format.getBytesPerSampleChannels() == 0) {
            sonicWriteShortToStream(sonStream, reinterpret_cast<const short *>(buf),
                                    static_cast<int>(origLen) / m_format.getBytesPerSampleChannels());
            int currentLen;
            while ((currentLen = sonicReadShortFromStream(sonStream,
                                                          reinterpret_cast<short *>
                                                          (sonicBuffer + len * m_format.getChannelCount()),
                                                          0x7fffffff))) {
                len += currentLen;
            }
        } else
            ILLEGAL_STATE("Incomplete Int16!");
        len *= m_format.getBytesPerSampleChannels();
        ring_buffer_size_t bufAvailCount = PaUtil_GetRingBufferWriteAvailable(&m_ringBuffer);
 
        if (bufAvailCount < len) return false;
        void *ptr[2] = {nullptr};
        ring_buffer_size_t sizes[2] = {0};
 
        PaUtil_GetRingBufferWriteRegions(&m_ringBuffer, static_cast<ring_buffer_size_t>(len), &ptr[0], &sizes[0],
                                         &ptr[1],
                                         &sizes[1]);
        memcpy(ptr[0], sonicBuffer, static_cast<size_t>(sizes[0]));
        memcpy(ptr[1], sonicBuffer + sizes[0], static_cast<size_t>(sizes[1]));
        dataInfoQueue.enqueue({origLen, len, static_cast<qreal>(origLen) / len});
        PaUtil_AdvanceRingBufferWriteIndex(&m_ringBuffer, static_cast<ring_buffer_size_t>(len));
        return true;
    }
 
    size_t clear() {
        if (m_state != PlaybackState::STOPPED) {
            qWarning() << "clear make no effect when state != STOPPED.";
        }
        // 需要保证此刻没有读写操作
        PaUtil_FlushRingBuffer(&m_ringBuffer);
        return 0;
    }
 
 
    [[nodiscard]] qreal getProcessSecs(bool backward) const {
        if (m_state == PlaybackState::STOPPED) { return m_startPoint; }
        auto processSec = static_cast<double>(m_format.durationOfBytes(m_dataWritten - m_dataLastWrote));
        if (backward) {
            return m_startPoint - processSec;
        } else {
            return m_startPoint + processSec;
        }
    }
 
    void setStartPoint(double t = 0.0) {
        if (std::isnan(t)) {
            qWarning() << "Trying set start point to NaN";
        }
        if (m_state == PlaybackState::STOPPED) {
            m_startPoint = t;
            m_dataWritten = 0;
        } else {
            qWarning() << "setTimeBase make no effect when state != STOPPED";
        }
    }
 
 
    void setVolume(qreal newVolume) {
        m_volume = qBound(0.0, newVolume, 1.0);
        sonicSetVolume(sonStream, static_cast<float>(newVolume));
    }
 
    void setPitch(qreal newPitch) {
        m_pitch = qBound(0.0, newPitch, 16.0);
        sonicSetPitch(sonStream, static_cast<float>(newPitch));
    }
 
    void setSpeed(qreal newSpeed) {
        m_speedFactor = qBound(0.0, newSpeed, MAX_SPEED_FACTOR);
        sonicSetSpeed(sonStream, static_cast<float>(newSpeed));
    }
 
    [[nodiscard]] qreal volume() const {
        return m_volume;
    }
 
    [[nodiscard]] qreal speed() const {
        return m_speedFactor;
    }
 
    [[nodiscard]] qreal pitch() const {
        return m_pitch;
    }
 
    void _getDeviceList() {
        devicesList.clear();
        int devicesCount = Pa_GetDeviceCount();
        for (auto index = 0; index < devicesCount; index++) {
            auto deviceInfo = Pa_GetDeviceInfo(index);
            QString deviceName = Pa_GetDeviceInfo(index)->name;
            if (deviceInfo->maxOutputChannels < 2) continue;
#ifdef WIN32
            if (deviceInfo->hostApi != PaHostApiTypeId::paDirectSound) continue;
#endif
            devicesList.push_back(deviceName);
            qDebug() << deviceName;
        }
    }
 
    QString getSelectedOutputDevice() { return selectedOutputDevice; }
 
    void restartStream(const std::function<void()> &betweenInitAndOpen) {
        std::lock_guard lock(paStreamLock);
        if (paInitialized) {
            Pa_AbortStream(m_stream);
            Pa_Terminate();
        }
        Pa_Initialize();
        paInitialized = true;
        if (betweenInitAndOpen) betweenInitAndOpen();
        initializeStream();
        if (m_state == PlaybackState::PLAYING) {
            startStreamSafe();
        }
    }
 
    void refreshDevicesList() {
        qDebug() << "Refreshing Devices list...";
        auto middleFunc = [this] {
            _getDeviceList();
        };
        restartStream(middleFunc);
        emit signalAudioOutputDeviceListChanged();
        emit signalDeviceSwitched();
    }
 
    QStringList getAudioDeviceList() {
        return devicesList;
    }
 
    void setFormat(const PonyAudioFormat &format) {
        std::unique_lock lock(paStreamLock);
        m_format = {PonyPlayer::Int16, format.getSampleRate(), format.getChannelCount()};
        lock.unlock();
        restartStream(nullptr);
    }
 
 
signals:
 
    void stateChanged();
 
    void resourceInsufficient();
 
    void signalAudioOutputDeviceListChanged();
 
    void signalDeviceSwitched();
 
public slots:
 
    void onAudioOutputDevicesChanged() {
        refreshDevicesList();
    }
 
    void requestDeviceSwitch(const QString &device) {
        qDebug() << "change audio output device to " << device;
        selectedOutputDevice = device;
        std::unique_lock lock(paStreamLock);
        if (paInitialized) {
            Pa_AbortStream(m_stream);
            Pa_Terminate();
        }
        paInitialized = false;
        initializeStream();
        if (m_state == PlaybackState::PLAYING) {
            startStreamSafe();
        }
        lock.unlock();
        emit signalDeviceSwitched();
    }
 
    PonyAudioFormat getCurrentDeviceFormat() {
        return m_deviceFormat;
    }
};