demuxer.hpp

浏览该文件的文档.

//
// Created by ColorsWind on 2022/5/6.
//
#pragma once
 
#include <QObject>
#include <utility>
#include "private/dispatcher.hpp"
#include "audioformat.hpp"
 
class Demuxer : public QObject {
    Q_OBJECT
    PONY_THREAD_AFFINITY(DECODER)
private:
    DemuxDispatcherBase *m_worker = nullptr;
    DecodeDispatcher *m_forward = nullptr;
    ReverseDecodeDispatcher *m_backward = nullptr;
 
    QThread *m_affinityThread = nullptr;
    std::mutex m_workerLock;
public:
 
 
    explicit Demuxer(QObject *parent) : QObject(nullptr) {
        m_affinityThread = new QThread;
        m_affinityThread->setObjectName(PonyPlayer::DECODER);
        this->moveToThread(m_affinityThread);
        m_affinityThread->start();
    }
 
    ~Demuxer() override {
        qDebug() << "Destroy Demuxer";
        m_affinityThread->quit();
    }
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    VideoFrameRef getPicture() {
        std::unique_lock lock(m_workerLock);
        return m_worker->getPicture();
    }
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    qreal frontPicture() {
        std::unique_lock lock(m_workerLock);
        return m_worker->frontPicture();
    }
 
    PONY_THREAD_SAFE int skipPicture(const std::function<bool(qreal)> &predicate) {
        std::unique_lock lock(m_workerLock);
        return m_worker->skipPicture(predicate);
    }
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    AudioFrame getSample() {
        std::unique_lock lock(m_workerLock);
        return m_worker->getSample();
    }
 
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    qreal frontSample() {
        std::unique_lock lock(m_workerLock);
        return m_worker->frontSample();
    }
 
    PONY_THREAD_SAFE int skipSample(const std::function<bool(qreal)> &predicate) {
        std::unique_lock lock(m_workerLock);
        return m_worker->skipSample(predicate);
    }
 
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    qreal audioDuration() {
        std::unique_lock lock(m_workerLock);
        return m_forward ? m_forward->getAudionLength() : 0.0;
    }
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    qreal videoDuration() {
        std::unique_lock lock(m_workerLock);
        return m_forward ? m_forward->getVideoLength() : 0.0;
    }
 
    PONY_GUARD_BY(MAIN, FRAME, DECODER)
 
    QStringList getTracks() {
        std::unique_lock lock(m_workerLock);
        if (m_forward) {
            return m_forward->getTracks();
        } else {
            return {u"没有打开的文件"_qs};
        }
    }
 
    PONY_THREAD_SAFE bool isBackward() {
        std::unique_lock lock(m_workerLock);
        return dynamic_cast<ReverseDecodeDispatcher *>(m_worker);
    }
 
 
    PONY_THREAD_SAFE bool hasVideo() {
        std::unique_lock lock(m_workerLock);
        return m_forward && m_forward->hasVideo();
    }
 
 
 
    PONY_CONDITION("OpenFileResult")
    PONY_THREAD_SAFE void pause() {
        std::unique_lock lock(m_workerLock);
        m_worker->statePause();
    }
 
    PONY_THREAD_SAFE bool isFileOpen() {
        std::unique_lock lock(m_workerLock);
        return m_worker != nullptr;
    }
 
    PONY_GUARD_BY(FRAME) void flush() {
        std::unique_lock lock(m_workerLock);
        m_worker->flush();
    }
 
    PONY_THREAD_SAFE void start() {
        std::unique_lock lock(m_workerLock);
        qDebug() << "Start Decoder";
        m_worker->stateResume();
    }
 
    void setEnableAudio(bool enable) {
        m_worker->setEnableAudio(enable);
    }
 
    PonyAudioFormat getInputFormat() {
        std::unique_lock lock(m_workerLock);
        if (m_worker) {
            return m_worker->getAudioInputFormat();
        } else {
            return PonyPlayer::DEFAULT_AUDIO_FORMAT;
        }
 
    }
 
    void setOutputFormat(PonyAudioFormat format) {
        std::unique_lock lock(m_workerLock);
        m_forward->setAudioOutputFormat(format);
        m_backward->setAudioOutputFormat(std::move(format));
    }
 
 
public slots:
 
    void seek(qreal secs) {
        m_worker->seek(secs);
    }
 
    void setAudioIndex(StreamIndex index) {
        m_forward->setAudioIndex(index);
    }
 
    void openFile(const std::string &fn) {
        qDebug() << "Demuxer Open file" << QString::fromUtf8(fn);
        // call on video decoder thread
        std::unique_lock lock(m_workerLock);
        if (m_worker) {
            qWarning() << "Already open file:" << m_worker->filename.c_str();
            emit openFileResult(PonyPlayer::OpenFileResultType::FAILED, QPrivateSignal());
            return;
        }
        PonyPlayer::OpenFileResultType result;
        try {
            m_forward = new DecodeDispatcher(fn, result, DEFAULT_STREAM_INDEX, DEFAULT_STREAM_INDEX, this);
            m_backward = new ReverseDecodeDispatcher(fn, this);
            m_worker = m_forward;
        } catch (std::runtime_error &ex) {
            qWarning() << "Error opening file:" << ex.what();
            m_worker = nullptr;
            m_backward = nullptr;
            m_forward = nullptr;
            emit openFileResult(result, QPrivateSignal());
            return;
        }
        lock.unlock();
        m_worker->stateResume();
        emit openFileResult(result, QPrivateSignal());
        qDebug() << "Open file success.";
    }
 
 
    void backward() {
        std::unique_lock lock(m_workerLock);
        m_worker = m_backward;
        m_forward->flush();
    }
 
    void forward() {
        std::unique_lock lock(m_workerLock);
        m_worker = m_forward;
        m_backward->flush();
    };
 
    void close() {
        std::unique_lock lock(m_workerLock);
        if (m_worker) {
            qDebug() << "Close file" << m_worker->filename.c_str();
            m_worker = nullptr;
            if (m_forward) {
                m_forward->statePause();
                m_forward->deleteLater();
                m_forward = nullptr;
            }
            if (m_backward) {
                m_backward->statePause();
                m_backward->deleteLater();
                m_backward = nullptr;
            }
        } else {
            qWarning() << "Try to close file while no file has been opened.";
        }
    }
 
    void setTrack(int i) {
        std::unique_lock lock(m_workerLock);
        m_worker->setTrack(i);
    }
 
 
    void test_onWork() {
        m_worker->test_onWork();
    }
 
signals:
 
    void openFileResult(PonyPlayer::OpenFileResultType result, QPrivateSignal);
};