QVideoStream/videorendereritem.cpp at master · DarkShrill/QVideoStream · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include "videorendereritem.h"
#include <QSGSimpleTextureNode>
#include <QSGTexture>
#include <QDebug>
#include <QQuickWindow>

#include "videodecoder.h"

VideoRendererItem::VideoRendererItem(QQuickItem* parent)
    : QQuickItem(parent),
    m_decoder(new VideoDecoder(this)) {
    setFlag(ItemHasContents, true);
    connect(m_decoder, &VideoDecoder::frameReady, this, &VideoRendererItem::onFrameReceived, Qt::QueuedConnection);
}

VideoRendererItem::~VideoRendererItem() {
    stop();
}

QString VideoRendererItem::url() const {
    return m_url;
}

void VideoRendererItem::setUrl(const QString& url) {
    if (m_url == url) {
        return;
    }
    m_url = url;
    emit urlChanged();
}

bool VideoRendererItem::forceCpuMode() const {
    return m_forceCpuMode;
}

void VideoRendererItem::setForceCpuMode(bool forceCpuMode) {
    if (m_forceCpuMode == forceCpuMode) {
        return;
    }
    m_forceCpuMode = forceCpuMode;
    emit forceCpuModeChanged();
}

bool VideoRendererItem::isPlaying() const {
    return m_playing;
}

void VideoRendererItem::play() {
    start(m_url);
}

void VideoRendererItem::start(const QString& url) {
    if (url.isEmpty()) {
        return;
    }

    setUrl(url);
    if (m_decoder->isDecoding()) {
        m_decoder->stopDecoding();
        m_decoder->wait();
    }

    m_decoder->startDecoding(m_url);
    if (!m_playing) {
        m_playing = true;
        emit playingChanged();
    }
}

void VideoRendererItem::stop() {
    if (m_decoder->isDecoding()) {
        m_decoder->stopDecoding();
        m_decoder->wait();
    }

    if (m_playing) {
        m_playing = false;
        emit playingChanged();
    }
}

void VideoRendererItem::releaseResources() {
    stop();
}

void VideoRendererItem::onFrameReceived(QByteArray data, int width, int height, int stride) {
    QImage image(reinterpret_cast<const uchar*>(data.constData()), width, height, stride, QImage::Format_RGB888);
    image = image.copy();

    {
        QMutexLocker locker(&m_mutex);
        m_image = image;
        m_newFrameAvailable = true;
    }

    emit frameImageReady(image);
    update();
}

QSGNode* VideoRendererItem::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData*) {
    QSGSimpleTextureNode* node = static_cast<QSGSimpleTextureNode*>(oldNode);
    if (!m_newFrameAvailable) {
        return node;
    }

    QImage image;
    {
        QMutexLocker locker(&m_mutex);
        if (!m_fpsTimer.isValid()) {
            m_fpsTimer.start();
        }

        ++m_frameCounter;
        if (m_fpsTimer.elapsed() >= 1000) {
            m_frameCounter = 0;
            m_fpsTimer.restart();
        }

        image = m_image;
        m_newFrameAvailable = false;
    }

    if (!node) {
        node = new QSGSimpleTextureNode();
    } else if (node->texture()) {
        delete node->texture();
    }

    QSGTexture* texture = window()->createTextureFromImage(image);
    node->setTexture(texture);
    node->setRect(boundingRect());
    return node;
}