Differential D18570 Diff 53757 plugins/platforms/drm/egl_stream_backend.cpp

Changeset View

Standalone View

View Options

plugins/platforms/drm/egl_stream_backend.cpp

  • This file was added.
1​/********************************************************************
2​ KWin - the KDE window manager
3​ This file is part of the KDE project.
4​
5​Copyright (C) 2019 NVIDIA Inc.
6​
7​This program is free software; you can redistribute it and/or modify
8​it under the terms of the GNU General Public License as published by
9​the Free Software Foundation; either version 2 of the License, or
10​(at your option) any later version.
11​
12​This program is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​GNU General Public License for more details.
16​
17​You should have received a copy of the GNU General Public License
18​along with this program. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​#include "egl_stream_backend.h"
21​#include "composite.h"
22​#include "drm_backend.h"
23​#include "drm_output.h"
24​#include "drm_object_crtc.h"
25​#include "drm_object_plane.h"
26​#include "logging.h"
27​#include "logind.h"
28​#include "options.h"
29​#include "scene.h"
30​#include "screens.h"
31​#include "wayland_server.h"
32​#include <kwinglplatform.h>
33​#include <QOpenGLContext>
34​#include <KWayland/Server/surface_interface.h>
35​#include <KWayland/Server/buffer_interface.h>
36​#include <KWayland/Server/eglstream_controller_interface.h>
37​#include <KWayland/Server/display.h>
38​#include <KWayland/Server/resource.h>
39​#include <wayland-server-core.h>
40​
41​namespace KWin
42​{
43​
44​typedef EGLStreamKHR (*PFNEGLCREATESTREAMATTRIBNV)(EGLDisplay, EGLAttrib *);
45​typedef EGLBoolean (*PFNEGLGETOUTPUTLAYERSEXT)(EGLDisplay, EGLAttrib *, EGLOutputLayerEXT *, EGLint, EGLint *);
46​typedef EGLBoolean (*PFNEGLSTREAMCONSUMEROUTPUTEXT)(EGLDisplay, EGLStreamKHR, EGLOutputLayerEXT);
47​typedef EGLSurface (*PFNEGLCREATESTREAMPRODUCERSURFACEKHR)(EGLDisplay, EGLConfig, EGLStreamKHR, EGLint *);
48​typedef EGLBoolean (*PFNEGLDESTROYSTREAMKHR)(EGLDisplay, EGLStreamKHR);
49​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLAttrib *);
50​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)(EGLDisplay, EGLStreamKHR);
51​typedef EGLBoolean (*PFNEGLQUERYSTREAMATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLenum, EGLAttrib *);
52​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERRELEASEKHR)(EGLDisplay, EGLStreamKHR);
53​typedef EGLBoolean (*PFNEGLQUERYWAYLANDBUFFERWL)(EGLDisplay, wl_resource *, EGLint, EGLint *);
54​PFNEGLCREATESTREAMATTRIBNV pEglCreateStreamAttribNV = nullptr;
55​PFNEGLGETOUTPUTLAYERSEXT pEglGetOutputLayersEXT = nullptr;
56​PFNEGLSTREAMCONSUMEROUTPUTEXT pEglStreamConsumerOutputEXT = nullptr;
57​PFNEGLCREATESTREAMPRODUCERSURFACEKHR pEglCreateStreamProducerSurfaceKHR = nullptr;
58​PFNEGLDESTROYSTREAMKHR pEglDestroyStreamKHR = nullptr;
59​PFNEGLSTREAMCONSUMERACQUIREATTRIBNV pEglStreamConsumerAcquireAttribNV = nullptr;
60​PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR pEglStreamConsumerGLTextureExternalKHR = nullptr;
61​PFNEGLQUERYSTREAMATTRIBNV pEglQueryStreamAttribNV = nullptr;
62​PFNEGLSTREAMCONSUMERRELEASEKHR pEglStreamConsumerReleaseKHR = nullptr;
63​PFNEGLQUERYWAYLANDBUFFERWL pEglQueryWaylandBufferWL = nullptr;
64​
65​#ifndef EGL_CONSUMER_AUTO_ACQUIRE_EXT
66​#define EGL_CONSUMER_AUTO_ACQUIRE_EXT 0x332B
67​#endif
68​
69​#ifndef EGL_DRM_MASTER_FD_EXT
70​#define EGL_DRM_MASTER_FD_EXT 0x333C
71​#endif
72​
73​#ifndef EGL_DRM_FLIP_EVENT_DATA_NV
74​#define EGL_DRM_FLIP_EVENT_DATA_NV 0x333E
75​#endif
76​
77​#ifndef EGL_WAYLAND_EGLSTREAM_WL
78​#define EGL_WAYLAND_EGLSTREAM_WL 0x334B
79​#endif
80​
81​#ifndef EGL_WAYLAND_Y_INVERTED_WL
82​#define EGL_WAYLAND_Y_INVERTED_WL 0x31DB
83​#endif
84​
85​EglStreamBackend::EglStreamBackend(DrmBackend *b)
86​ : AbstractEglBackend(), m_backend(b)
87​{
88​ setIsDirectRendering(true);
89​ setSyncsToVBlank(true);
90​ connect(m_backend, &DrmBackend::outputAdded, this, &EglStreamBackend::createOutput);
91​ connect(m_backend, &DrmBackend::outputRemoved, this,
92​ [this] (DrmOutput *output) {
93​ auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
94​ [output] (const Output &o) {
95​ return o.output == output;
96​ });
97​ if (it == m_outputs.end()) {
98​ return;
99​ }
zzagUnsubmitted
Done

Please indent the lambda with 4 spaces. The pattern looks like as follows

connect(sender, &Sender::changed, context,
    [this](Value *value) {
        // Body
    }
);
zzag: Please indent the lambda with 4 spaces. The pattern looks like as follows ```lang=cpp connect…
100​ cleanupOutput(*it);
101​ m_outputs.erase(it);
102​ });
103​}
104​
105​EglStreamBackend::~EglStreamBackend()
106​{
107​ cleanup();
108​}
109​
110​void EglStreamBackend::cleanupSurfaces()
111​{
112​ for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
113​ cleanupOutput(*it);
114​ }
115​ m_outputs.clear();
116​}
117​
118​void EglStreamBackend::cleanupOutput(const Output &o)
119​{
120​ if (o.buffer != nullptr) {
121​ delete o.buffer;
122​ }
123​ if (o.eglSurface != EGL_NO_SURFACE) {
124​ eglDestroySurface(eglDisplay(), o.eglSurface);
125​ }
126​ if (o.eglStream != EGL_NO_STREAM_KHR) {
127​ pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
128​ }
129​}
130​
131​bool EglStreamBackend::initializeEgl()
132​{
133​ initClientExtensions();
134​ EGLDisplay display = m_backend->sceneEglDisplay();
135​ if (display == EGL_NO_DISPLAY) {
136​ if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_device_base")) &&
137​ !(hasClientExtension(QByteArrayLiteral("EGL_EXT_device_query")) &&
138​ hasClientExtension(QByteArrayLiteral("EGL_EXT_device_enumeration")))) {
139​ setFailed("Missing required EGL client extension: "
140​ "EGL_EXT_device_base or "
141​ "EGL_EXT_device_query and EGL_EXT_device_enumeration");
142​ return false;
143​ }
144​
145​ // Try to find the EGLDevice corresponding to our DRM device file
146​ int numDevices;
147​ eglQueryDevicesEXT(0, nullptr, &numDevices);
148​ QVector<EGLDeviceEXT> devices(numDevices);
149​ eglQueryDevicesEXT(numDevices, devices.data(), &numDevices);
150​ for (EGLDeviceEXT device : devices) {
151​ const char *drmDeviceFile = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
152​ if (m_backend->devNode() != drmDeviceFile) {
153​ continue;
154​ }
155​
156​ const char *deviceExtensionCString = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
157​ QByteArray deviceExtensions = QByteArray::fromRawData(deviceExtensionCString,
158​ qstrlen(deviceExtensionCString));
159​ if (!deviceExtensions.split(' ').contains(QByteArrayLiteral("EGL_EXT_device_drm"))) {
160​ continue;
161​ }
162​
163​ EGLint platformAttribs[] = {
164​ EGL_DRM_MASTER_FD_EXT, m_backend->fd(),
165​ EGL_NONE
166​ };
167​ display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, platformAttribs);
168​ break;
169​ }
170​ }
171​
172​ if (display == EGL_NO_DISPLAY) {
173​ setFailed("No suitable EGL device found");
174​ return false;
175​ }
176​
177​ setEglDisplay(display);
178​ if (!initEglAPI()) {
179​ return false;
180​ }
181​
182​ const QVector<QByteArray> requiredExtensions = {
183​ QByteArrayLiteral("EGL_EXT_output_base"),
184​ QByteArrayLiteral("EGL_EXT_output_drm"),
185​ QByteArrayLiteral("EGL_KHR_stream"),
186​ QByteArrayLiteral("EGL_KHR_stream_producer_eglsurface"),
187​ QByteArrayLiteral("EGL_EXT_stream_consumer_egloutput"),
188​ QByteArrayLiteral("EGL_NV_stream_attrib"),
189​ QByteArrayLiteral("EGL_EXT_stream_acquire_mode"),
cfeckUnsubmitted
Not Done

ext is only a byte array. To add it to a string, Qt needs to know in which encoding the byte array is. Please use ... + QLatin1String(ext).

cfeck: `ext` is only a byte array. To add it to a string, Qt needs to know in which encoding the byte…
ekurzingerAuthorUnsubmitted
Not Done

I believe QString::operator+ does this implicitly

ekurzinger: I believe QString::operator+ does this implicitly
190​ QByteArrayLiteral("EGL_KHR_stream_consumer_gltexture"),
191​ QByteArrayLiteral("EGL_WL_wayland_eglstream")
192​ };
193​ for (const QByteArray &ext : requiredExtensions) {
194​ if (!hasExtension(ext)) {
195​ setFailed(QStringLiteral("Missing required EGL extension: ") + ext);
196​ return false;
197​ }
198​ }
199​
200​ pEglCreateStreamAttribNV = (PFNEGLCREATESTREAMATTRIBNV)eglGetProcAddress("eglCreateStreamAttribNV");
201​ pEglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXT)eglGetProcAddress("eglGetOutputLayersEXT");
202​ pEglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXT)eglGetProcAddress("eglStreamConsumerOutputEXT");
203​ pEglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHR)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
204​ pEglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHR)eglGetProcAddress("eglDestroyStreamKHR");
205​ pEglStreamConsumerAcquireAttribNV = (PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)eglGetProcAddress("eglStreamConsumerAcquireAttribNV");
206​ pEglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR");
207​ pEglQueryStreamAttribNV = (PFNEGLQUERYSTREAMATTRIBNV)eglGetProcAddress("eglQueryStreamAttribNV");
208​ pEglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHR)eglGetProcAddress("eglStreamConsumerReleaseKHR");
209​ pEglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWL)eglGetProcAddress("eglQueryWaylandBufferWL");
210​ return true;
211​}
212​
213​EglStreamBackend::StreamTexture *EglStreamBackend::lookupStreamTexture(KWayland::Server::SurfaceInterface *surface)
214​{
215​ auto it = m_streamTextures.find(surface);
216​ return it != m_streamTextures.end() ?
217​ &it.value() :
218​ nullptr;
219​}
220​
221​void EglStreamBackend::attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
222​ void *eglStream,
223​ wl_array *attribs)
224​{
225​ QVector<EGLAttrib> streamAttribs;
226​ streamAttribs << EGL_WAYLAND_EGLSTREAM_WL << (EGLAttrib)eglStream;
227​ EGLAttrib *attribArray = (EGLAttrib *)attribs->data;
228​ for (unsigned int i = 0; i < attribs->size; ++i) {
229​ streamAttribs << attribArray[i];
230​ }
231​ streamAttribs << EGL_NONE;
232​
233​ EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs.data());
234​ if (stream == EGL_NO_STREAM_KHR) {
235​ qCWarning(KWIN_DRM) << "Failed to create EGL stream";
236​ return;
237​ }
238​
239​ GLuint texture;
240​ StreamTexture *st = lookupStreamTexture(surface);
241​ if (st != nullptr) {
242​ pEglDestroyStreamKHR(eglDisplay(), st->stream);
243​ st->stream = stream;
244​ st->swap = true;
245​ texture = st->textures[1];
246​ } else {
247​ StreamTexture newSt = { stream, { 0, 0 }, false };
248​ glGenTextures(2, newSt.textures);
249​ m_streamTextures.insert(surface, newSt);
250​ texture = newSt.textures[0];
251​
252​ connect(surface, &KWayland::Server::Resource::unbound, this,
253​ [surface, this]() {
254​ const StreamTexture &st = m_streamTextures.take(surface);
255​ pEglDestroyStreamKHR(eglDisplay(), st.stream);
256​ glDeleteTextures(2, st.textures);
257​ });
258​ }
259​
260​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
261​ if (!pEglStreamConsumerGLTextureExternalKHR(eglDisplay(), stream)) {
262​ qCWarning(KWIN_DRM) << "Failed to bind EGL stream to texture";
263​ }
264​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
265​}
266​
267​void EglStreamBackend::init()
268​{
269​ if (!m_backend->atomicModeSetting()) {
270​ setFailed("EGLStream backend requires atomic modesetting");
271​ return;
272​ }
273​
274​ if (!initializeEgl()) {
275​ setFailed("Failed to initialize EGL api");
276​ return;
zzagUnsubmitted
Done

Missing return?

zzag: Missing return?
277​ }
278​ if (!initRenderingContext()) {
279​ setFailed("Failed to initialize rendering context");
zzagUnsubmitted
Done

Please use nullptr.

zzag: Please use nullptr.
280​ return;
281​ }
282​
283​ initKWinGL();
284​ setSupportsBufferAge(false);
285​ initWayland();
286​
287​ using namespace KWayland::Server;
288​ m_eglStreamControllerInterface = waylandServer()->display()->createEglStreamControllerInterface();
289​ connect(m_eglStreamControllerInterface, &EglStreamControllerInterface::streamConsumerAttached, this,
290​ &EglStreamBackend::attachStreamConsumer);
291​ m_eglStreamControllerInterface->create();
292​ if (!m_eglStreamControllerInterface->isValid()) {
293​ setFailed("failed to initialize wayland-eglstream-controller interface");
294​ }
295​}
296​
297​bool EglStreamBackend::initRenderingContext()
298​{
299​ initBufferConfigs();
300​
301​ if (!createContext()) {
zzagUnsubmitted
Done

Please no goto. Use a lambda.

zzag: Please no `goto`. Use a lambda.
302​ return false;
303​ }
304​
305​ const auto outputs = m_backend->drmOutputs();
306​ for (DrmOutput *drmOutput : outputs) {
307​ createOutput(drmOutput);
308​ }
309​ if (m_outputs.isEmpty()) {
310​ qCCritical(KWIN_DRM) << "Failed to create output surface";
311​ return false;
312​ }
313​ // set our first surface as the one for the abstract backend
314​ setSurface(m_outputs.first().eglSurface);
315​
316​ return makeContextCurrent(m_outputs.first());
317​}
318​
319​bool EglStreamBackend::resetOutput(Output &o, DrmOutput *drmOutput)
320​{
321​ o.output = drmOutput;
322​ if (o.buffer != nullptr) {
323​ delete o.buffer;
324​ }
325​ // dumb buffer used for modesetting
cfeckUnsubmitted
Done

Space before :

cfeck: Space before `:`
326​ o.buffer = m_backend->createBuffer(drmOutput->pixelSize());
327​
328​ EGLAttrib streamAttribs[] = {
329​ EGL_STREAM_FIFO_LENGTH_KHR, 0, // mailbox mode
330​ EGL_CONSUMER_AUTO_ACQUIRE_EXT, EGL_FALSE,
331​ EGL_NONE
332​ };
333​ EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs);
334​ if (stream == EGL_NO_STREAM_KHR) {
335​ qCCritical(KWIN_DRM) << "Failed to create EGL stream for output";
336​ return false;
337​ }
338​
339​ EGLAttrib outputAttribs[3];
340​ if (drmOutput->primaryPlane()) {
341​ outputAttribs[0] = EGL_DRM_PLANE_EXT;
342​ outputAttribs[1] = drmOutput->primaryPlane()->id();
343​ } else {
344​ outputAttribs[0] = EGL_DRM_CRTC_EXT;
345​ outputAttribs[1] = drmOutput->crtc()->id();
346​ }
347​ outputAttribs[2] = EGL_NONE;
348​ EGLint numLayers;
349​ EGLOutputLayerEXT outputLayer;
350​ pEglGetOutputLayersEXT(eglDisplay(), outputAttribs, &outputLayer, 1, &numLayers);
351​ if (numLayers == 0) {
352​ qCCritical(KWIN_DRM) << "No EGL output layers found";
353​ return false;
354​ }
355​
356​ pEglStreamConsumerOutputEXT(eglDisplay(), stream, outputLayer);
357​ EGLint streamProducerAttribs[] = {
358​ EGL_WIDTH, drmOutput->pixelSize().width(),
359​ EGL_HEIGHT, drmOutput->pixelSize().height(),
360​ EGL_NONE
361​ };
362​ EGLSurface eglSurface = pEglCreateStreamProducerSurfaceKHR(eglDisplay(), config(), stream,
363​ streamProducerAttribs);
364​ if (eglSurface == EGL_NO_SURFACE) {
365​ qCCritical(KWIN_DRM) << "Failed to create EGL surface for output";
366​ return false;
367​ }
368​
369​ if (o.eglSurface != EGL_NO_SURFACE) {
370​ if (surface() == o.eglSurface) {
371​ setSurface(eglSurface);
372​ }
373​ eglDestroySurface(eglDisplay(), o.eglSurface);
374​ }
375​
376​ if (o.eglStream != EGL_NO_STREAM_KHR) {
377​ pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
378​ }
379​
380​ o.eglStream = stream;
381​ o.eglSurface = eglSurface;
382​ return true;
383​}
384​
385​void EglStreamBackend::createOutput(DrmOutput *drmOutput)
386​{
387​ Output o;
388​ if (!resetOutput(o, drmOutput)) {
389​ return;
390​ }
391​
392​ connect(drmOutput, &DrmOutput::modeChanged, this,
393​ [drmOutput, this] {
394​ auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
395​ [drmOutput] (const auto &o) {
396​ return o.output == drmOutput;
397​ }
398​ );
399​ if (it == m_outputs.end()) {
400​ return;
401​ }
402​ resetOutput(*it, drmOutput);
403​ }
404​ );
405​ m_outputs << o;
romanggUnsubmitted
Done

To reduce indent, do instead:

if (!resetOutput(o, drmOutput)) {
    return;
}
...
romangg: To reduce indent, do instead: ``` if (!resetOutput(o, drmOutput)) { return; } ... ```
406​}
407​
408​bool EglStreamBackend::makeContextCurrent(const Output &output)
409​{
410​ const EGLSurface surface = output.eglSurface;
411​ if (surface == EGL_NO_SURFACE) {
412​ return false;
413​ }
414​
415​ if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
416​ qCCritical(KWIN_DRM) << "Failed to make EGL context current";
417​ return false;
418​ }
419​
420​ EGLint error = eglGetError();
421​ if (error != EGL_SUCCESS) {
422​ qCWarning(KWIN_DRM) << "Error occurred while making EGL context current" << error;
423​ return false;
424​ }
425​
426​ const QSize &overall = screens()->size();
427​ const QRect &v = output.output->geometry();
428​ qreal scale = output.output->scale();
429​ glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
430​ overall.width() * scale, overall.height() * scale);
431​ return true;
432​}
433​
434​bool EglStreamBackend::initBufferConfigs()
435​{
436​ const EGLint configAttribs[] = {
437​ EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR,
438​ EGL_RED_SIZE, 1,
439​ EGL_GREEN_SIZE, 1,
cfeckUnsubmitted
Not Done

Not sure here, but I think these should also not be reference variables.

cfeck: Not sure here, but I think these should also not be reference variables.
ekurzingerAuthorUnsubmitted
Not Done

They're const so I don't think it really makes much of a difference. If anything references save a couple of bytes and avoid a struct copy.

ekurzinger: They're const so I don't think it really makes much of a difference. If anything references…
440​ EGL_BLUE_SIZE, 1,
441​ EGL_ALPHA_SIZE, 0,
442​ EGL_RENDERABLE_TYPE, isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
443​ EGL_CONFIG_CAVEAT, EGL_NONE,
444​ EGL_NONE,
445​ };
446​ EGLint count;
447​ EGLConfig config;
448​ if (!eglChooseConfig(eglDisplay(), configAttribs, &config, 1, &count)) {
449​ qCCritical(KWIN_DRM) << "Failed to query available EGL configs";
450​ return false;
451​ }
452​ if (count == 0) {
453​ qCCritical(KWIN_DRM) << "No suitable EGL config found";
454​ return false;
455​ }
456​
457​ setConfig(config);
458​ return true;
459​}
460​
461​void EglStreamBackend::present()
462​{
463​ for (auto &o : m_outputs) {
464​ makeContextCurrent(o);
465​ presentOnOutput(o);
466​ }
467​}
468​
469​void EglStreamBackend::presentOnOutput(EglStreamBackend::Output &o)
470​{
471​ eglSwapBuffers(eglDisplay(), o.eglSurface);
472​ if (m_backend->present(o.buffer, o.output)) {
romanggUnsubmitted
Done

Check if the condition is not fulfilled and if this is the case return early.

romangg: Check if the condition is not fulfilled and if this is the case return early.
473​ EGLAttrib acquireAttribs[] = {
474​ EGL_DRM_FLIP_EVENT_DATA_NV, (EGLAttrib)o.output,
475​ EGL_NONE,
476​ };
cfeckUnsubmitted
Done

Space

cfeck: Space
477​ if (!pEglStreamConsumerAcquireAttribNV(eglDisplay(), o.eglStream, acquireAttribs)) {
478​ qCWarning(KWIN_DRM) << "Failed to acquire output EGL stream frame";
479​ }
480​ }
481​}
482​
483​void EglStreamBackend::screenGeometryChanged(const QSize &size)
484​{
485​ Q_UNUSED(size)
486​}
487​
488​SceneOpenGLTexturePrivate *EglStreamBackend::createBackendTexture(SceneOpenGLTexture *texture)
489​{
490​ return new EglStreamTexture(texture, this);
491​}
492​
493​QRegion EglStreamBackend::prepareRenderingFrame()
494​{
495​ startRenderTimer();
496​ return QRegion();
497​}
498​
499​QRegion EglStreamBackend::prepareRenderingForScreen(int screenId)
500​{
501​ const Output &o = m_outputs.at(screenId);
502​ makeContextCurrent(o);
503​ return o.output->geometry();
504​}
505​
506​void EglStreamBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
507​{
508​ Q_UNUSED(renderedRegion)
509​ Q_UNUSED(damagedRegion)
510​}
511​
512​void EglStreamBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
513​{
514​ Q_UNUSED(renderedRegion);
515​ Q_UNUSED(damagedRegion);
516​ Output &o = m_outputs[screenId];
517​ presentOnOutput(o);
518​}
519​
520​bool EglStreamBackend::usesOverlayWindow() const
521​{
522​ return false;
523​}
524​
525​bool EglStreamBackend::perScreenRendering() const
526​{
527​ return true;
528​}
529​
530​/************************************************
531​ * EglTexture
532​ ************************************************/
533​
534​EglStreamTexture::EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend)
535​ : AbstractEglTexture(texture, backend), m_backend(backend), m_fbo(0), m_rbo(0)
536​{
537​}
538​
539​EglStreamTexture::~EglStreamTexture()
540​{
541​ glDeleteRenderbuffers(1, &m_rbo);
542​ glDeleteFramebuffers(1, &m_fbo);
543​}
544​
545​bool EglStreamTexture::acquireStreamFrame(EGLStreamKHR stream)
546​{
547​ EGLAttrib streamState;
548​ if (!pEglQueryStreamAttribNV(m_backend->eglDisplay(), stream,
549​ EGL_STREAM_STATE_KHR, &streamState)) {
550​ qCWarning(KWIN_DRM) << "Failed to query EGL stream state";
551​ return false;
552​ }
553​
554​ if (streamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
555​ if (pEglStreamConsumerAcquireAttribNV(m_backend->eglDisplay(), stream, nullptr)) {
556​ return true;
557​ } else {
558​ qCWarning(KWIN_DRM) << "Failed to acquire EGL stream frame";
559​ }
560​ }
561​
562​ // Re-use previous texture contents if no new frame is available
563​ // or if acquisition fails for some reason
564​ return false;
565​}
566​
567​void EglStreamTexture::createFbo()
568​{
569​ glDeleteRenderbuffers(1, &m_rbo);
570​ glDeleteFramebuffers(1, &m_fbo);
571​
572​ glGenFramebuffers(1, &m_fbo);
573​ glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
574​ glGenRenderbuffers(1, &m_rbo);
575​ glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
576​ glRenderbufferStorage(GL_RENDERBUFFER, m_format, m_size.width(), m_size.height());
577​ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
578​ glBindRenderbuffer(GL_RENDERBUFFER, 0);
579​ glBindFramebuffer(GL_FRAMEBUFFER, 0);
580​}
581​
582​// Renders the contents of the given EXTERNAL_OES texture
583​// to the scratch framebuffer, then copies this to m_texture
584​void EglStreamTexture::copyExternalTexture(GLuint tex)
585​{
586​ GLint oldViewport[4], oldProgram;
587​ glGetIntegerv(GL_VIEWPORT, oldViewport);
588​ glViewport(0, 0, m_size.width(), m_size.height());
589​ glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgram);
590​ glUseProgram(0);
591​ glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
592​ glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
593​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
594​ glEnable(GL_TEXTURE_EXTERNAL_OES);
595​
596​ GLfloat yTop = texture()->isYInverted() ? 0 : 1;
597​ glBegin(GL_QUADS);
598​ glTexCoord2f(0, yTop);
599​ glVertex2f(-1, 1);
600​ glTexCoord2f(0, 1 - yTop);
601​ glVertex2f(-1, -1);
602​ glTexCoord2f(1, 1 - yTop);
603​ glVertex2f(1, -1);
604​ glTexCoord2f(1, yTop);
605​ glVertex2f(1, 1);
606​ glEnd();
607​
608​ texture()->bind();
609​ glCopyTexImage2D(m_target, 0, m_format, 0, 0, m_size.width(), m_size.height(), 0);
610​ texture()->unbind();
611​
612​ glDisable(GL_TEXTURE_EXTERNAL_OES);
613​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
614​ glBindRenderbuffer(GL_RENDERBUFFER, 0);
615​ glBindFramebuffer(GL_FRAMEBUFFER, 0);
616​ glUseProgram(oldProgram);
617​ glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
618​}
619​
620​bool EglStreamTexture::attachBuffer(KWayland::Server::BufferInterface *buffer)
621​{
622​ QSize oldSize = m_size;
623​ m_size = buffer->size();
624​ GLenum oldFormat = m_format;
625​ m_format = buffer->hasAlphaChannel() ? GL_RGBA : GL_RGB;
626​
627​ EGLint yInverted, wasYInverted = texture()->isYInverted();
628​ if (!pEglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted)) {
629​ yInverted = EGL_TRUE;
630​ }
631​ texture()->setYInverted(yInverted);
632​ updateMatrix();
633​
634​ return oldSize != m_size ||
635​ oldFormat != m_format ||
636​ wasYInverted != texture()->isYInverted();
637​}
638​
639​bool EglStreamTexture::loadTexture(WindowPixmap *pixmap)
640​{
641​ using namespace KWayland::Server;
642​ SurfaceInterface *surface = pixmap->surface();
643​ EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
644​ if (!pixmap->buffer().isNull() && st != nullptr) {
645​
646​ glGenTextures(1, &m_texture);
647​ texture()->setWrapMode(GL_CLAMP_TO_EDGE);
648​ texture()->setFilter(GL_LINEAR);
649​
650​ attachBuffer(surface->buffer());
651​ createFbo();
652​ surface->resetTrackedDamage();
653​
654​ if (acquireStreamFrame(st->stream)) {
655​ if (st->swap) {
656​ GLuint tmp = st->textures[0];
657​ st->textures[0] = st->textures[1];
658​ st->textures[1] = tmp;
659​ st->swap = false;
660​ }
661​ copyExternalTexture(st->textures[0]);
662​ if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
663​ qCWarning(KWIN_DRM) << "Failed to release EGL stream";
664​ }
665​ }
666​ return true;
667​ } else {
668​ // Not an EGLStream surface
669​ return AbstractEglTexture::loadTexture(pixmap);
670​ }
671​}
672​
673​void EglStreamTexture::updateTexture(WindowPixmap *pixmap)
674​{
675​ using namespace KWayland::Server;
676​ SurfaceInterface *surface = pixmap->surface();
677​ const EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
678​ if (!pixmap->buffer().isNull() && st != nullptr) {
679​
680​ if (attachBuffer(surface->buffer())) {
681​ createFbo();
682​ }
683​ surface->resetTrackedDamage();
684​
685​ if (acquireStreamFrame(st->stream)) {
686​ copyExternalTexture(st->textures[0]);
687​ if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
688​ qCWarning(KWIN_DRM) << "Failed to release EGL stream";
689​ }
690​ }
691​ } else {
692​ // Not an EGLStream surface
693​ AbstractEglTexture::updateTexture(pixmap);
694​ }
695​}
696​
697​} // namespace