qquickvideooutput_p.h

Enable keyboard shortcuts

// Copyright (C) 2021 The Qt Company Ltd.

// Copyright (C) 2016 Research In Motion

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#ifndef QQUICKVIDEOOUTPUT_P_H

#define QQUICKVIDEOOUTPUT_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QtCore/qrect.h>

#include <QtCore/qpointer.h>

#include <QtCore/qmutex.h>

#include <QtQuick/qquickitem.h>

#include <QtMultimedia/qvideoframe.h>

#include <QtMultimedia/qvideoframeformat.h>

#include <QtMultimedia/qvideosink.h>

#include <QtMultimediaQuick/private/qtmultimediaquickglobal_p.h>

#include <thread>

QT_BEGIN_NAMESPACE

class QQuickVideoBackend;

class QVideoOutputOrientationHandler;

class QVideoSink;

class QSGVideoNode;

class QVideoFrameTexturePool;

using QVideoFrameTexturePoolWPtr = std::weak_ptr<QVideoFrameTexturePool>;

class QQuickVideoSink : public QVideoSink

    Q_OBJECT

    QML_NAMED_ELEMENT(VideoSink)

public:

    QQuickVideoSink(QObject *parent = nullptr) : QVideoSink(parent)

        connect(this, &QVideoSink::videoFrameChanged, this, &QQuickVideoSink::videoFrameChanged,

                Qt::DirectConnection);

Q_SIGNALS:

    void videoFrameChanged();

};

class Q_MULTIMEDIAQUICK_EXPORT QQuickVideoOutput : public QQuickItem

    Q_OBJECT

    Q_DISABLE_COPY(QQuickVideoOutput)

    Q_PROPERTY(FillMode fillMode READ fillMode WRITE setFillMode NOTIFY fillModeChanged)

    Q_PROPERTY(EndOfStreamPolicy endOfStreamPolicy READ endOfStreamPolicy WRITE setEndOfStreamPolicy

                       NOTIFY endOfStreamPolicyChanged REVISION(6, 9))

    Q_PROPERTY(int orientation READ orientation WRITE setOrientation NOTIFY orientationChanged)

    Q_PROPERTY(bool mirrored READ mirrored WRITE setMirrored NOTIFY mirroredChanged REVISION(6, 9))

    Q_PROPERTY(QRectF sourceRect READ sourceRect NOTIFY sourceRectChanged)

    Q_PROPERTY(QRectF contentRect READ contentRect NOTIFY contentRectChanged)

    Q_PROPERTY(QVideoSink* videoSink READ videoSink CONSTANT)

    Q_MOC_INCLUDE(qvideosink.h)

    Q_MOC_INCLUDE(qvideoframe.h)

    QML_NAMED_ELEMENT(VideoOutput)

public:

    enum FillMode

        Stretch            = Qt::IgnoreAspectRatio,

        PreserveAspectFit  = Qt::KeepAspectRatio,

        PreserveAspectCrop = Qt::KeepAspectRatioByExpanding

};

    Q_ENUM(FillMode)

    enum EndOfStreamPolicy

        ClearOutput,

        KeepLastFrame

};

    Q_ENUM(EndOfStreamPolicy)

    QQuickVideoOutput(QQuickItem *parent = 0);

    ~QQuickVideoOutput() override;

    Q_INVOKABLE QVideoSink *videoSink() const;

    FillMode fillMode() const;

    void setFillMode(FillMode mode);

    int orientation() const;

    void setOrientation(int);

    bool mirrored() const;

    void setMirrored(bool);

    QRectF sourceRect() const;

    QRectF contentRect() const;

    EndOfStreamPolicy endOfStreamPolicy() const;

    void setEndOfStreamPolicy(EndOfStreamPolicy policy);

    Q_REVISION(6, 9) Q_INVOKABLE void clearOutput();

Q_SIGNALS:

    void sourceChanged();

    void fillModeChanged(QQuickVideoOutput::FillMode);

    void orientationChanged();

    void mirroredChanged();

    void sourceRectChanged();

    void contentRectChanged();

    void endOfStreamPolicyChanged(QQuickVideoOutput::EndOfStreamPolicy);

protected:

    QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;

    void itemChange(ItemChange change, const ItemChangeData &changeData) override;

    void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;

    void releaseResources() override;

private:

    QSize nativeSize() const;

    void updateGeometry();

    QRectF adjustedViewport() const;

    void setFrame(const QVideoFrame &frame);

    void initRhiForSink();

    void updateHdr(QSGVideoNode *videoNode);

    void disconnectWindowConnections();

private Q_SLOTS:

    void _q_newFrame(QSize);

    void _q_updateGeometry();

private:

    QSize m_nativeSize;

    bool m_geometryDirty = true;

    QRectF m_lastRect;      // Cache of last rect to avoid recalculating geometry

    QRectF m_contentRect;   // Destination pixel coordinates, unclipped

    int m_orientation = 0;

    bool m_mirrored = false;

    QtVideo::Rotation m_frameDisplayingRotation = QtVideo::Rotation::None;

    Qt::AspectRatioMode m_aspectRatioMode = Qt::KeepAspectRatio;

    QPointer<QQuickWindow> m_window;

    QVideoSink *m_sink = nullptr;

    QVideoFrameFormat m_videoFormat;

    QVideoFrameTexturePoolWPtr m_texturePool;

    QVideoFrame m_frame;

    bool m_frameChanged = false;

    QMutex m_frameMutex;

    QRectF m_renderedRect;         // Destination pixel coordinates, clipped

    QRectF m_sourceTextureRect;    // Source texture coordinates

    EndOfStreamPolicy m_endOfStreamPolicy = ClearOutput;

    struct DestructorGuard

        QMutex m_mutex;

        bool m_isAlive{ true };

        template <typename Functor>

        void runWhileAlive(Functor &&f)

            QMutexLocker lock(&m_mutex);

            if (m_isAlive)

                f();

};

    std::shared_ptr<DestructorGuard> m_destructorGuard = std::make_shared<DestructorGuard>();

    template <typename Functor>

    auto makeGuardedCall(Functor &&f)

        return [f = std::forward<Functor>(f), guard = m_destructorGuard](auto... params) {

            if (g_signalBackoff) {

                Q_UNLIKELY_BRANCH;

                std::this_thread::sleep_for(*g_signalBackoff);

            guard->runWhileAlive([&] {

                f(params...);

});

};

    // for testing

    static std::optional<std::chrono::nanoseconds> g_signalBackoff;

public:

    static void setSignalBackoff(std::optional<std::chrono::nanoseconds>);

};

QT_END_NAMESPACE

#endif // QQUICKVIDEOOUTPUT_P_H