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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/****************************************************************************
**
** Copyright (C) 2020 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtWebEngine module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef COMPOSITOR_H
#define COMPOSITOR_H
#include <QtWebEngineCore/private/qtwebenginecoreglobal_p.h>
QT_BEGIN_NAMESPACE
class QImage;
class QSize;
QT_END_NAMESPACE
namespace viz {
class FrameSinkId;
} // namespace viz
namespace QtWebEngineCore {
// Produces composited frames for display.
//
// Used by quick/widgets libraries for accessing the frame and
// controlling frame swapping. Must be cast to a subclass to access
// the frame as QImage or OpenGL texture, etc.
class Q_WEBENGINECORE_PRIVATE_EXPORT Compositor
{
struct Binding;
public:
// Identifies the implementation type.
enum class Type {
Software,
OpenGL,
};
// Identifies a compositor.
//
// The purpose of assigning ids to compositors is to allow the
// corresponding observer to be registered before the compositor
// itself is created, which is necessary since the creation
// happens on a different thread in the depths of viz.
//
// (Maps to viz::FrameSinkId internally).
struct Id
{
quint32 client_id;
quint32 sink_id;
Id(viz::FrameSinkId);
};
// Pointer to Compositor or Observer that holds a lock to prevent
// either from being unbound and destroyed.
template<typename T>
class Handle
{
public:
Handle(std::nullptr_t) : m_data(nullptr) { }
Handle(T *data) : m_data(data) { }
Handle(Handle &&that) : m_data(that.m_data) { that.m_data = nullptr; }
~Handle()
{
if (m_data)
Compositor::unlockBindings();
}
T *operator->() const { return m_data; }
T &operator*() const { return *m_data; }
explicit operator bool() const { return m_data; }
private:
T *m_data;
};
// Observes the compositor corresponding to the given id.
//
// Only one observer can exist per compositor.
class Q_WEBENGINECORE_PRIVATE_EXPORT Observer
{
public:
// Binding to compositor
void bind(Id id);
void unbind();
// Compositor if bound
Handle<Compositor> compositor();
// There's a new frame ready, time to swapFrame().
virtual void readyToSwap() = 0;
protected:
Observer() = default;
~Observer() { if (m_binding) unbind(); }
private:
Binding *m_binding = nullptr;
};
// Type determines which methods can be called.
Type type() const { return m_type; }
// Binding to observer.
void bind(Id id);
void unbind();
// Observer if bound.
Handle<Observer> observer();
// Update to next frame if possible.
virtual void swapFrame() = 0;
// Ratio of pixels to DIPs.
//
// Don't use the devicePixelRatio of QImage, it's always 1.
virtual float devicePixelRatio() = 0;
// Size of frame in pixels.
virtual QSize size() = 0;
// Whether frame needs an alpha channel.
//
// In software mode, the image format can be either
// QImage::Format_ARGB32_Premultiplied or
// QImage::Format_RGBA8888_Premultiplied
//
// In OpenGL mode, the texture format is either GL_RGBA or GL_RGB.
virtual bool hasAlphaChannel() = 0;
// (Software) QImage of the frame.
//
// This is a big image so we should try not to make copies of it.
// In particular, the client should drop its QImage reference
// before calling swapFrame(), otherwise each swap will cause a
// detach.
virtual QImage image();
// (OpenGL) Wait on texture fence in Qt's current OpenGL context.
virtual void waitForTexture();
// (OpenGL) Texture of the frame.
virtual int textureId();
protected:
Compositor(Type type) : m_type(type) { }
virtual ~Compositor() { if (m_binding) unbind(); }
private:
template<typename T>
friend class Handle;
class BindingMap;
static void unlockBindings();
const Type m_type;
Binding *m_binding = nullptr;
};
} // namespace QtWebEngineCore
#endif // !COMPOSITOR_H
|
