hurricane.hpp

浏览该文件的文档.

//
// Created by ColorsWind on 2022/5/6.
//
 
#pragma once
#ifndef PONYPLAYER_HURRICANE_HPP
#define PONYPLAYER_HURRICANE_HPP
 
#include <QObject>
#include <utility>
#include "framecontroller.hpp"
#include "fireworks.hpp"
 
class Hurricane : public Fireworks {
Q_OBJECT
    QML_ADDED_IN_VERSION(1, 0)
    QML_ELEMENT
public:
    enum HurricaneState {
        CLOSING,       
        LOADING,       
        INVALID,       
        PRE_PLAY,      
        PLAYING,       
        PRE_PAUSE,     
        PAUSED         
    };
 
    Q_ENUM(HurricaneState)
 
    QML_ELEMENT
    Q_PROPERTY(qreal pitch READ getPitch WRITE setPitch NOTIFY pitchChanged)
    Q_PROPERTY(HurricaneState state READ getState NOTIFY stateChanged FINAL)
    Q_PROPERTY(QStringList audioDeviceList READ getAudioDeviceList NOTIFY audioOutputDeviceChanged)
    Q_PROPERTY(QStringList tracks READ getTracks NOTIFY openFileResult)
    Q_PROPERTY(bool backwardStatus READ isBackward NOTIFY backwardStatusChanged)
    Q_PROPERTY(int track READ getTrack WRITE setTrack NOTIFY trackChanged)
    Q_PROPERTY(
            QString currentOutputDevice READ getCurrentOutputDevice WRITE setCurrentOutputDevice NOTIFY currentOutputDeviceChanged)
    Q_PROPERTY(double speed READ getSpeed WRITE setSpeed NOTIFY speedChanged)
 
 
private:
    bool backwardStatus = false;
private:
    HurricaneState state = HurricaneState::INVALID;
private:
    FrameController *frameController;
    int track = -1;
    double speed = 1.0;
public:
    explicit Hurricane(QQuickItem *parent = nullptr) : Fireworks(parent) {
        frameController = new FrameController(this);
 
        connect(this, &Hurricane::signalStart, frameController, &FrameController::start);
        connect(this, &Hurricane::signalPause, frameController, &FrameController::pause);
 
        connect(this, &Hurricane::signalOpenFile, frameController, &FrameController::openFile);
 
        connect(frameController, &FrameController::openFileResult, this, &Hurricane::slotOpenFileResult);
        connect(this, &Hurricane::signalClose, frameController, &FrameController::close);
        connect(frameController, &FrameController::setPicture, this, &Hurricane::setVideoFrame);
 
        connect(this, &Hurricane::signalSeek, frameController, &FrameController::seek);
        connect(frameController, &FrameController::signalPositionChangedBySeek, this,
                &Hurricane::slotPositionChangedBySeek);
 
        connect(frameController, &FrameController::playbackStateChanged, this, &Hurricane::slotPlaybackStateChanged);
 
        connect(this, &Hurricane::stateChanged, [this] {
            qDebug() << "State Changed to" << QVariant::fromValue(state).toString();
        });
 
        connect(frameController, &FrameController::signalAudioOutputDevicesChanged, this,
                &Hurricane::audioOutputDeviceChanged);
        connect(frameController, &FrameController::signalDeviceSwitched, this, &Hurricane::currentOutputDeviceChanged);
        connect(frameController, &FrameController::resourcesEnd, this, &Hurricane::resourcesEnd);
        emit signalPlayerInitializing(QPrivateSignal());
#ifdef DEBUG_FLAG_AUTO_OPEN
        openFile(QUrl::fromLocalFile(QDir::homePath().append(u"/581518754-1-208.mp4"_qs)).url());
#endif
    }
 
    virtual ~Hurricane() override {
        frameController->pause();
        frameController->deleteLater();
        qWarning() << "Destroy HurricanePlayer.";
    }
 
    HurricaneState getState() { return state; }
 
    int getTrack() {
        return track;
    }
 
    double getSpeed() {
        return speed;
    }
 
    bool isBackward() { return backwardStatus; }
 
    QStringList getAudioDeviceList() { return frameController->getAudioDeviceList(); }
 
 
signals:
 
    void stateChanged();
 
    void openFileResult(PonyPlayer::OpenFileResultType result, QPrivateSignal);
 
    void positionChangedBySeek();
 
    void audioOutputDeviceChanged();
 
    void backwardStatusChanged();
 
    void trackChanged();
 
    void currentOutputDeviceChanged();
 
    void pitchChanged();
 
    void speedChanged();
 
    void resourcesEnd();
 
Q_SIGNALS:
 
    // 下面这些方法用于与 VideoPlayWorker 通信
    // 约定两者通信的方法信号以 signal 开头, 槽函数以 slot 开头
    // 约定信号只能由所属的类的实例 emit
    void signalPlayerInitializing(QPrivateSignal);
 
    void signalStart(QPrivateSignal);
 
    void signalPause(QPrivateSignal);
 
    void signalClose(QPrivateSignal);
 
    void signalOpenFile(const QString &path, QPrivateSignal);
 
    void signalSeek(qreal pos, QPrivateSignal);
 
 
public slots:
 
    Q_INVOKABLE void openFile(const QString &url, bool autoClose = true) {
        if (autoClose && (state == HurricaneState::PLAYING || state == PRE_PLAY)) {
            emit pause();
        }
        if (autoClose && (state == HurricaneState::PAUSED || state == PRE_PAUSE)) {
            emit close();
        }
        if (state == HurricaneState::CLOSING || state == HurricaneState::INVALID) {
            if (state == HurricaneState::CLOSING) {
                // wait for the operation to complete
                QCoreApplication::processEvents();
            }
            state = HurricaneState::LOADING;
            emit stateChanged();
            backwardStatus = false;
            emit backwardStatusChanged();
            emit signalOpenFile(QUrl(url).toLocalFile(), QPrivateSignal());
            qDebug() << "Open file:" << url;
        }
    };
 
 
    Q_INVOKABLE void start() {
        if (state == HurricaneState::PAUSED || state == HurricaneState::PRE_PAUSE) {
            state = HurricaneState::PRE_PLAY;
            emit stateChanged();
            emit signalStart(QPrivateSignal());
            qDebug() << "Start play video.";
        }
    }
 
    Q_INVOKABLE void pause() {
        if (state == HurricaneState::PLAYING || state == HurricaneState::PRE_PLAY) {
            state = HurricaneState::PRE_PAUSE;
            emit stateChanged();
            emit signalPause(QPrivateSignal());
            qDebug() << "Pause.";
        }
    }
 
    Q_INVOKABLE void close() {
        if (state == HurricaneState::PRE_PAUSE || state == HurricaneState::PAUSED) {
            state = HurricaneState::CLOSING;
            emit stateChanged();
            this->setVideoFrame(VideoFrameRef());
            emit signalClose(QPrivateSignal());
        }
    }
 
    Q_INVOKABLE void setVolume(qreal volume) {
        frameController->setVolume(volume);
    }
 
    Q_INVOKABLE void setPitch(qreal pitch) {
        frameController->setPitch(pitch);
    }
 
    Q_INVOKABLE void setSpeed(qreal speed) {
        frameController->setSpeed(speed);
        this->speed = speed;
        emit speedChanged();
    }
 
    Q_INVOKABLE void setCurrentOutputDevice(QString deviceName) {
        frameController->setSelectedAudioOutputDevice(std::move(deviceName));
    }
 
    Q_INVOKABLE QString getCurrentOutputDevice() {
        return frameController->getSelectedAudioOutputDevice();
    }
 
    Q_INVOKABLE qreal getAudioDuration() { return frameController->getAudioDuration(); }
 
    Q_INVOKABLE qreal getVideoDuration() { return frameController->getVideoDuration(); }
 
    Q_INVOKABLE qreal getPTS() {
        qreal pts = frameController->getPreferablePos();
        if (std::isnan(pts)) {
            qWarning() << "getPTS return NaN";
        }
        return pts;
    }
 
    Q_INVOKABLE void seek(qreal pos) {
        // only available on PLAY/PAUSE
        bool playing = false;
        switch (state) {
            case HurricaneState::PLAYING:
            case HurricaneState::PRE_PLAY:
                playing = true;
                /* fall through */
            case HurricaneState::PAUSED:
            case HurricaneState::PRE_PAUSE:
                break;
            default:
                return;
        }
        if (pos < 0 || pos > getVideoDuration())
            return;
        state = PRE_PAUSE;
        emit stateChanged();
//    emit signalPause(QPrivateSignal());
        emit signalSeek(pos, QPrivateSignal());
        if (playing) {
            emit signalStart(QPrivateSignal());
        }
        qDebug() << "HurricanePlayer: Seek" << pos;
    }
 
    Q_INVOKABLE QStringList getTracks() {
        if (state == LOADING || state == INVALID) {
            qWarning() << "Get tracks when" << state;
        }
        return frameController->getTracks();
    }
 
    Q_INVOKABLE void setTrack(int i) {
        bool playing = false;
        switch (state) {
            case HurricaneState::PLAYING:
            case HurricaneState::PRE_PLAY:
                playing = true;
                /* fall through */
            case HurricaneState::PAUSED:
            case HurricaneState::PRE_PAUSE:
                break;
            default:
                return;
        }
        state = PRE_PAUSE;
        emit stateChanged();
        frameController->setTrack(i);
        track = i;
        emit trackChanged();
        if (playing) {
            emit signalStart(QPrivateSignal());
        }
 
        qDebug() << "Set Music Track" << i;
    }
 
 
    Q_INVOKABLE void forward() {
        bool playing = false;
        switch (state) {
            case HurricaneState::PLAYING:
            case HurricaneState::PRE_PLAY:
                playing = true;
                /* fall through */
            case HurricaneState::PAUSED:
            case HurricaneState::PRE_PAUSE:
                break;
            default:
                return;
        }
        state = PRE_PAUSE;
        emit stateChanged();
        backwardStatus = false;
        emit backwardStatusChanged();
        frameController->forward();
        if (playing) {
            emit signalStart(QPrivateSignal());
        }
        qDebug() << "forward";
    }
 
    Q_INVOKABLE void backward() {
        bool playing = false;
        switch (state) {
            case HurricaneState::PLAYING:
            case HurricaneState::PRE_PLAY:
                playing = true;
                /* fall through */
            case HurricaneState::PAUSED:
            case HurricaneState::PRE_PAUSE:
                break;
            default:
                return;
        }
        state = PRE_PAUSE;
        emit stateChanged();
        backwardStatus = true;
        emit backwardStatusChanged();
        frameController->backward();
        if (playing) {
            emit signalStart(QPrivateSignal());
        }
        qDebug() << "backward";
    }
 
    Q_INVOKABLE void toggleBackward() {
        if (isBackward()) {
            forward();
        } else {
            backward();
        }
    }
 
    Q_INVOKABLE bool hasVideo() {
        return frameController != nullptr && frameController->hasVideo();
    }
 
    Q_INVOKABLE qreal getPitch() {
        return frameController ? frameController->getPitch() : 1.0;
    }
 
 
private slots:
 
    void slotPositionChangedBySeek() { emit positionChangedBySeek(); }
 
    void slotPlaybackStateChanged(bool isPlaying) {
        if (isPlaying) {
            state = PLAYING;
        } else {
            state = PAUSED;
        }
        emit stateChanged();
    };
 
    void slotOpenFileResult(PonyPlayer::OpenFileResultType result) {
        if (result != PonyPlayer::OpenFileResultType::FAILED) {
            state = PAUSED;
            track = 0;
        } else {
            state = INVALID;
            track = -1;
        }
        emit openFileResult(result, QPrivateSignal());
        emit trackChanged();
        emit stateChanged();
    }
 
 
};
 
 
#endif //PONYPLAYER_HURRICANE_HPP