Differential D18465 Diff 50093 plugins/platforms/wayland/egl_wayland_backend.cpp

Changeset View

Standalone View

View Options

plugins/platforms/wayland/egl_wayland_backend.cpp

1 ​
2/******************************************************************** 1​/********************************************************************
3 KWin - the KDE window manager 2​ KWin - the KDE window manager
4 This file is part of the KDE project. 3​ This file is part of the KDE project.
5 4​
6Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org> 5​Copyright 2019 Roman Gilg <subdiff@gmail.com>
6​Copyright 2013 Martin Gräßlin <mgraesslin@kde.org>
7 7​
8This program is free software; you can redistribute it and/or modify 8​This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by 9​it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or 10​the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version. 11​(at your option) any later version.
12 12​
13This program is distributed in the hope that it will be useful, 13​This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of 14​but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details. 16​GNU General Public License for more details.
17 17​
18You should have received a copy of the GNU General Public License 18​You should have received a copy of the GNU General Public License
19along with this program. If not, see <http://www.gnu.org/licenses/>. 19​along with this program. If not, see <http://www.gnu.org/licenses/>.
20*********************************************************************/ 20​*********************************************************************/
21#define WL_EGL_PLATFORM 1 21​#define WL_EGL_PLATFORM 1
22​
22#include "egl_wayland_backend.h" 23​#include "egl_wayland_backend.h"
23// kwin 24​
25​#include "wayland_backend.h"
26​#include "wayland_output.h"
27​
24#include "composite.h" 28​#include "composite.h"
25#include "logging.h" 29​#include "logging.h"
26#include "options.h" 30​#include "options.h"
27#include "wayland_backend.h" 31​
28#include "wayland_server.h" 32​#include "wayland_server.h"
29#include <KWayland/Client/surface.h> 33​#include "screens.h"
34​
30// kwin libs 35​// kwin libs
31#include <kwinglplatform.h> 36​#include <kwinglplatform.h>
37​
32// KDE 38​// KDE
39​#include <KWayland/Client/surface.h>
33#include <KWayland/Server/buffer_interface.h> 40​#include <KWayland/Server/buffer_interface.h>
34#include <KWayland/Server/display.h> 41​#include <KWayland/Server/display.h>
42​
35// Qt 43​// Qt
36#include <QOpenGLContext> 44​#include <QOpenGLContext>
37 45​
38namespace KWin 46​namespace KWin
39{ 47​{
48​namespace Wayland
49​{
40 50​
41EglWaylandBackend::EglWaylandBackend(Wayland::WaylandBackend *b) 51​EglWaylandOutput::EglWaylandOutput(WaylandOutput *output, QObject *parent)
52​ : QObject(parent)
53​ , m_waylandOutput(output)
54​{
55​}
56​
57​bool EglWaylandOutput::init(EglWaylandBackend *backend)
58​{
59​ auto surface = m_waylandOutput->surface();
60​ const QSize &size = m_waylandOutput->geometry().size();
61​ auto overlay = wl_egl_window_create(*surface, size.width(), size.height());
62​ if (!overlay) {
63​ qCCritical(KWIN_WAYLAND_BACKEND) << "Creating Wayland Egl window failed";
64​ return false;
65​ }
66​ m_overlay = overlay;
67​
68​ EGLSurface eglSurface = EGL_NO_SURFACE;
69​ if (backend->havePlatformBase()) {
70​ eglSurface = eglCreatePlatformWindowSurfaceEXT(backend->eglDisplay(), backend->config(), (void *) overlay, nullptr);
71​ } else {
72​ eglSurface = eglCreateWindowSurface(backend->eglDisplay(), backend->config(), overlay, nullptr);
73​ }
74​ if (eglSurface == EGL_NO_SURFACE) {
75​ qCCritical(KWIN_WAYLAND_BACKEND) << "Create Window Surface failed";
76​ return false;
77​ }
78​ m_eglSurface = eglSurface;
79​
80​ connect(m_waylandOutput, &WaylandOutput::sizeChanged, this, &EglWaylandOutput::updateSize);
81​
82​ return true;
83​}
84​
85​void EglWaylandOutput::updateSize(const QSize &size)
86​{
87​ wl_egl_window_resize(m_overlay, size.width(), size.height(), 0, 0);
88​}
89​
90​EglWaylandBackend::EglWaylandBackend(WaylandBackend *b)
42 : AbstractEglBackend() 91​ : AbstractEglBackend()
43 , m_bufferAge(0) 92​ , m_backend(b)
44 , m_wayland(b) ​
45 , m_overlay(NULL) ​
46{ 93​{
47 if (!m_wayland) { 94​ if (!m_backend) {
48 setFailed("Wayland Backend has not been created"); 95​ setFailed("Wayland Backend has not been created");
49 return; 96​ return;
50 } 97​ }
51 qCDebug(KWIN_WAYLAND_BACKEND) << "Connected to Wayland display?" << (m_wayland->display() ? "yes" : "no" ); 98​ qCDebug(KWIN_WAYLAND_BACKEND) << "Connected to Wayland display?" << (m_backend->display() ? "yes" : "no" );
52 if (!m_wayland->display()) { 99​ if (!m_backend->display()) {
53 setFailed("Could not connect to Wayland compositor"); 100​ setFailed("Could not connect to Wayland compositor");
54 return; 101​ return;
55 } 102​ }
56 connect(m_wayland, SIGNAL(shellSurfaceSizeChanged(QSize)), SLOT(overlaySizeChanged(QSize))); 103​
57 // Egl is always direct rendering 104​ // Egl is always direct rendering
58 setIsDirectRendering(true); 105​ setIsDirectRendering(true);
106​
107​ connect(m_backend, &WaylandBackend::outputAdded, this, &EglWaylandBackend::createEglWaylandOutput);
108​ connect(m_backend, &WaylandBackend::outputRemoved, this,
109​ [this] (WaylandOutput *output) {
110​ auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
111​ [output] (const EglWaylandOutput *o) {
112​ return o->m_waylandOutput == output;
113​ }
114​ );
115​ if (it == m_outputs.end()) {
116​ return;
117​ }
118​ cleanupOutput(*it);
119​ m_outputs.erase(it);
120​ }
121​ );
59} 122​}
60 123​
61EglWaylandBackend::~EglWaylandBackend() 124​EglWaylandBackend::~EglWaylandBackend()
62{ 125​{
63 cleanup(); 126​ cleanup();
64 if (m_overlay) { ​
65 wl_egl_window_destroy(m_overlay); ​
66 } 127​}
128​
129​void EglWaylandBackend::cleanupSurfaces()
130​{
131​ for (auto o : m_outputs) {
132​ cleanupOutput(o);
133​ }
134​ m_outputs.clear();
135​}
136​
137​bool EglWaylandBackend::createEglWaylandOutput(WaylandOutput *waylandOutput)
138​{
139​ auto *output = new EglWaylandOutput(waylandOutput, this);
140​ if (output->init(this)) {
141​ return false;
142​ }
143​ m_outputs << output;
144​ return true;
145​}
146​
147​void EglWaylandBackend::cleanupOutput(EglWaylandOutput *output)
148​{
149​ wl_egl_window_destroy(output->m_overlay);
67} 150​}
68 151​
69bool EglWaylandBackend::initializeEgl() 152​bool EglWaylandBackend::initializeEgl()
70{ 153​{
71 initClientExtensions(); 154​ initClientExtensions();
72 EGLDisplay display = m_wayland->sceneEglDisplay(); 155​ EGLDisplay display = m_backend->sceneEglDisplay();
73 156​
74 // Use eglGetPlatformDisplayEXT() to get the display pointer 157​ // Use eglGetPlatformDisplayEXT() to get the display pointer
75 // if the implementation supports it. 158​ // if the implementation supports it.
76 if (display == EGL_NO_DISPLAY) { 159​ if (display == EGL_NO_DISPLAY) {
77 m_havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")); 160​ m_havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
78 if (m_havePlatformBase) { 161​ if (m_havePlatformBase) {
79 // Make sure that the wayland platform is supported 162​ // Make sure that the wayland platform is supported
80 if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_wayland"))) 163​ if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_backend")))
zzagUnsubmitted
Done

Does such extension exist?

zzag: Does such extension exist?
romanggAuthorUnsubmitted
Done

Pretty sure that not. Seems to be a search and replace error, when changing the m_wayland variable name to m_backen. THANKS!

romangg: Pretty sure that not. Seems to be a search and replace error, when changing the m_wayland…
81 return false; 164​ return false;
82 165​
83 display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_wayland->display(), nullptr); 166​ display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_backend->display(), nullptr);
84 } else { 167​ } else {
85 display = eglGetDisplay(m_wayland->display()); 168​ display = eglGetDisplay(m_backend->display());
86 } 169​ }
87 } 170​ }
88 171​
89 if (display == EGL_NO_DISPLAY) 172​ if (display == EGL_NO_DISPLAY)
90 return false; 173​ return false;
91 setEglDisplay(display); 174​ setEglDisplay(display);
92 return initEglAPI(); 175​ return initEglAPI();
93} 176​}
Show All 17 Lines
111bool EglWaylandBackend::initRenderingContext() 194​bool EglWaylandBackend::initRenderingContext()
112{ 195​{
113 initBufferConfigs(); 196​ initBufferConfigs();
114 197​
115 if (!createContext()) { 198​ if (!createContext()) {
116 return false; 199​ return false;
117 } 200​ }
118 201​
119 if (!m_wayland->surface()) { 202​ auto waylandOutputs = m_backend->waylandOutputs();
203​
204​ // we only allow to start with at least one output
205​ if (waylandOutputs.isEmpty()) {
120 return false; 206​ return false;
121 } 207​ }
122 208​
123 const QSize &size = m_wayland->shellSurfaceSize(); 209​ for (auto *out : waylandOutputs) {
124 auto s = m_wayland->surface(); 210​ if (!createEglWaylandOutput(out)) {
125 connect(s, &KWayland::Client::Surface::frameRendered, Compositor::self(), &Compositor::bufferSwapComplete); ​
126 m_overlay = wl_egl_window_create(*s, size.width(), size.height()); ​
127 if (!m_overlay) { ​
128 qCCritical(KWIN_WAYLAND_BACKEND) << "Creating Wayland Egl window failed"; ​
129 return false; 211​ return false;
130 } 212​ }
213​ }
131 214​
132 EGLSurface surface = EGL_NO_SURFACE; 215​ if (m_outputs.isEmpty()) {
133 if (m_havePlatformBase) 216​ qCCritical(KWIN_WAYLAND_BACKEND) << "Create Window Surfaces failed";
134 surface = eglCreatePlatformWindowSurfaceEXT(eglDisplay(), config(), (void *) m_overlay, nullptr); ​
135 else ​
136 surface = eglCreateWindowSurface(eglDisplay(), config(), m_overlay, nullptr); ​
137 ​
138 if (surface == EGL_NO_SURFACE) { ​
139 qCCritical(KWIN_WAYLAND_BACKEND) << "Create Window Surface failed"; ​
140 return false; 217​ return false;
141 } 218​ }
142 setSurface(surface); ​
143 219​
144 return makeContextCurrent(); 220​ auto *firstOutput = m_outputs.first();
221​ // set our first surface as the one for the abstract backend, just to make it happy
222​ setSurface(firstOutput->m_eglSurface);
223​ return makeContextCurrent(firstOutput);
145} 224​}
146 225​
147bool EglWaylandBackend::makeContextCurrent() 226​bool EglWaylandBackend::makeContextCurrent(EglWaylandOutput *output)
148{ 227​{
149 if (eglMakeCurrent(eglDisplay(), surface(), surface(), context()) == EGL_FALSE) { 228​ const EGLSurface eglSurface = output->m_eglSurface;
229​ if (eglSurface == EGL_NO_SURFACE) {
230​ return false;
231​ }
232​ if (eglMakeCurrent(eglDisplay(), eglSurface, eglSurface, context()) == EGL_FALSE) {
150 qCCritical(KWIN_WAYLAND_BACKEND) << "Make Context Current failed"; 233​ qCCritical(KWIN_WAYLAND_BACKEND) << "Make Context Current failed";
151 return false; 234​ return false;
152 } 235​ }
153 236​
154 EGLint error = eglGetError(); 237​ EGLint error = eglGetError();
155 if (error != EGL_SUCCESS) { 238​ if (error != EGL_SUCCESS) {
156 qCWarning(KWIN_WAYLAND_BACKEND) << "Error occurred while creating context " << error; 239​ qCWarning(KWIN_WAYLAND_BACKEND) << "Error occurred while creating context " << error;
157 return false; 240​ return false;
158 } 241​ }
242​
243​ // TODO: viewport is experimental, see comments in EglGbmBackend
davidedmundsonUnsubmitted
Done

I don't think that's true anymore. I did lots of fixes to it.
We can remove that comment

davidedmundson: I don't think that's true anymore. I did lots of fixes to it. We can remove that comment
244​ const QSize &overall = screens()->size();
davidedmundsonUnsubmitted
Done

Use of temporary values is weird.

davidedmundson: Use of temporary values is weird.
245​ const QRect &v = output->m_waylandOutput->geometry();
246​
247​ qreal scale = output->m_waylandOutput->scale();
248​
249​ glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
250​ overall.width() * scale, overall.height() * scale);
159 return true; 251​ return true;
160} 252​}
161 253​
162bool EglWaylandBackend::initBufferConfigs() 254​bool EglWaylandBackend::initBufferConfigs()
163{ 255​{
164 const EGLint config_attribs[] = { 256​ const EGLint config_attribs[] = {
165 EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 257​ EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
166 EGL_RED_SIZE, 1, 258​ EGL_RED_SIZE, 1,
Show All 17 Lines
184 } 276​ }
185 setConfig(configs[0]); 277​ setConfig(configs[0]);
186 278​
187 return true; 279​ return true;
188} 280​}
189 281​
190void EglWaylandBackend::present() 282​void EglWaylandBackend::present()
191{ 283​{
192 m_wayland->surface()->setupFrameCallback(); 284​ for (auto &s: m_outputs) {
romanggAuthorUnsubmitted
Done

* instead of &.

romangg: `*` instead of `&`.
285​ makeContextCurrent(s);
286​ presentOnSurface(s);
287​ }
288​}
289​
290​void EglWaylandBackend::presentOnSurface(EglWaylandOutput *output)
291​{
292​ output->m_waylandOutput->surface()->setupFrameCallback();
193 Compositor::self()->aboutToSwapBuffers(); 293​ Compositor::self()->aboutToSwapBuffers();
194 294​
195 if (supportsBufferAge()) { 295​ if (supportsBufferAge()) {
196 eglSwapBuffers(eglDisplay(), surface()); 296​ eglSwapBuffers(eglDisplay(), output->m_eglSurface);
197 eglQuerySurface(eglDisplay(), surface(), EGL_BUFFER_AGE_EXT, &m_bufferAge); 297​ eglQuerySurface(eglDisplay(), output->m_eglSurface, EGL_BUFFER_AGE_EXT, &output->m_bufferAge);
198 setLastDamage(QRegion()); ​
199 return; ​
200 } else { 298​ } else {
201 eglSwapBuffers(eglDisplay(), surface()); 299​ eglSwapBuffers(eglDisplay(), output->m_eglSurface);
202 setLastDamage(QRegion()); ​
203 } 300​ }
301​
204} 302​}
205 303​
206void EglWaylandBackend::screenGeometryChanged(const QSize &size) 304​void EglWaylandBackend::screenGeometryChanged(const QSize &size)
207{ 305​{
208 Q_UNUSED(size) 306​ Q_UNUSED(size)
209 // no backend specific code needed 307​ // no backend specific code needed
210 // TODO: base implementation in OpenGLBackend 308​ // TODO: base implementation in OpenGLBackend
211 309​
212 // The back buffer contents are now undefined 310​ // The back buffer contents are now undefined
213 m_bufferAge = 0; 311​ for (auto output : m_outputs) {
davidedmundsonUnsubmitted
Done

qAsConst

(in both places)

davidedmundson: qAsConst (in both places)
romanggAuthorUnsubmitted
Done

The vector elements are pointers. qAsConst does not have any advantage in this case. But I forgot the asterisk on the auto keyword. Maybe that's why you thought there should be qAsConst?

romangg: The vector elements are pointers. qAsConst does not have any advantage in this case. But I…
zzagUnsubmitted
Done

We need qAsConst to prevent QVector from detaching. (m_outputs can be shared, right?)

zzag: We need qAsConst to prevent QVector from detaching. (m_outputs can be shared, right?)
romanggAuthorUnsubmitted
Done

Container elements are only pointer values though. So the deep copy is negligible. That's what I meant. If you prefer I will add qAsConst though.

romangg: Container elements are only pointer values though. So the deep copy is negligible. That's what…
312​ output->m_bufferAge = 0;
313​ }
214} 314​}
215 315​
216SceneOpenGLTexturePrivate *EglWaylandBackend::createBackendTexture(SceneOpenGLTexture *texture) 316​SceneOpenGLTexturePrivate *EglWaylandBackend::createBackendTexture(SceneOpenGLTexture *texture)
217{ 317​{
218 return new EglWaylandTexture(texture, this); 318​ return new EglWaylandTexture(texture, this);
219} 319​}
220 320​
221QRegion EglWaylandBackend::prepareRenderingFrame() 321​QRegion EglWaylandBackend::prepareRenderingFrame()
222{ 322​{
223 if (!lastDamage().isEmpty()) ​
224 present(); ​
225 QRegion repaint; ​
226 if (supportsBufferAge()) ​
227 repaint = accumulatedDamageHistory(m_bufferAge); ​
228 eglWaitNative(EGL_CORE_NATIVE_ENGINE); 323​ eglWaitNative(EGL_CORE_NATIVE_ENGINE);
229 startRenderTimer(); 324​ startRenderTimer();
230 return repaint; 325​ return QRegion();
326​}
327​
328​QRegion EglWaylandBackend::prepareRenderingForScreen(int screenId)
329​{
330​ auto *output = m_outputs.at(screenId);
331​ makeContextCurrent(output);
332​ if (supportsBufferAge()) {
333​ QRegion region;
334​
335​ // Note: An age of zero means the buffer contents are undefined
336​ if (output->m_bufferAge > 0 && output->m_bufferAge <= output->m_damageHistory.count()) {
337​ for (int i = 0; i < output->m_bufferAge - 1; i++)
338​ region |= output->m_damageHistory[i];
339​ } else {
340​ region = output->m_waylandOutput->geometry();
341​ }
342​
343​ return region;
344​ }
345​ return QRegion();
231} 346​}
232 347​
233void EglWaylandBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion) 348​void EglWaylandBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
234{ 349​{
235 if (damagedRegion.isEmpty()) { 350​ Q_UNUSED(renderedRegion)
236 setLastDamage(QRegion()); 351​ Q_UNUSED(damagedRegion)
352​}
353​
354​void EglWaylandBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
355​{
356​ EglWaylandOutput *output = m_outputs[screenId];
357​ if (damagedRegion.intersected(output->m_waylandOutput->geometry()).isEmpty() && screenId == 0) {
237 358​
238 // If the damaged region of a window is fully occluded, the only 359​ // If the damaged region of a window is fully occluded, the only
239 // rendering done, if any, will have been to repair a reused back 360​ // rendering done, if any, will have been to repair a reused back
240 // buffer, making it identical to the front buffer. 361​ // buffer, making it identical to the front buffer.
241 // 362​ //
242 // In this case we won't post the back buffer. Instead we'll just 363​ // In this case we won't post the back buffer. Instead we'll just
243 // set the buffer age to 1, so the repaired regions won't be 364​ // set the buffer age to 1, so the repaired regions won't be
244 // rendered again in the next frame. 365​ // rendered again in the next frame.
245 if (!renderedRegion.isEmpty()) 366​ if (!renderedRegion.intersected(output->m_waylandOutput->geometry()).isEmpty()) {
246 glFlush(); 367​ glFlush();
247 ​
248 m_bufferAge = 1; ​
249 return; ​
250 } 368​ }
251 369​
252 setLastDamage(renderedRegion); 370​ for (auto *o : m_outputs) {
253 371​ o->m_bufferAge = 1;
254 if (!blocksForRetrace()) { 372​ }
255 // This also sets lastDamage to empty which prevents the frame from 373​ return;
256 // being posted again when prepareRenderingFrame() is called. ​
257 present(); ​
258 } else { ​
259 // Make sure that the GPU begins processing the command stream ​
260 // now and not the next time prepareRenderingFrame() is called. ​
261 glFlush(); ​
262 } 374​ }
375​ presentOnSurface(output);
263 376​
264 // Save the damaged region to history 377​ // Save the damaged region to history
265 if (supportsBufferAge()) 378​ // Note: damage history is only collected for the first screen. See EglGbmBackend
266 addToDamageHistory(damagedRegion); 379​ // for mor information regarding this limitation.
380​ if (supportsBufferAge() && screenId == 0) {
381​ if (output->m_damageHistory.count() > 10) {
382​ output->m_damageHistory.removeLast();
267} 383​ }
268 384​
269void EglWaylandBackend::overlaySizeChanged(const QSize &size) 385​ output->m_damageHistory.prepend(damagedRegion.intersected(output->m_waylandOutput->geometry()));
270{ 386​ }
271 wl_egl_window_resize(m_overlay, size.width(), size.height(), 0, 0); ​
272} 387​}
273 388​
274bool EglWaylandBackend::usesOverlayWindow() const 389​bool EglWaylandBackend::usesOverlayWindow() const
275{ 390​{
276 return false; 391​ return false;
277} 392​}
278 393​
394​bool EglWaylandBackend::perScreenRendering() const
395​{
396​ return true;
397​}
398​
279/************************************************ 399​/************************************************
280 * EglTexture 400​ * EglTexture
281 ************************************************/ 401​ ************************************************/
282 402​
283EglWaylandTexture::EglWaylandTexture(KWin::SceneOpenGLTexture *texture, KWin::EglWaylandBackend *backend) 403​EglWaylandTexture::EglWaylandTexture(KWin::SceneOpenGLTexture *texture, KWin::Wayland::EglWaylandBackend *backend)
284 : AbstractEglTexture(texture, backend) 404​ : AbstractEglTexture(texture, backend)
285{ 405​{
286} 406​}
287 407​
288EglWaylandTexture::~EglWaylandTexture() = default; 408​EglWaylandTexture::~EglWaylandTexture() = default;
289 409​
290} // namespace 410​}
411​}