Differential D18570 Diff 50397 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 "logging.h"
25​#include "logind.h"
26​#include "options.h"
27​#include "scene.h"
28​#include "screens.h"
29​#include "wayland_server.h"
30​#include <kwinglplatform.h>
31​#include <QOpenGLContext>
32​#include <KWayland/Server/surface_interface.h>
33​#include <KWayland/Server/buffer_interface.h>
34​#include <KWayland/Server/display.h>
35​#include <KWayland/Server/resource.h>
36​#include <wayland-server-core.h>
37​#include <dlfcn.h>
38​
39​namespace KWin
40​{
41​
42​typedef EGLStreamKHR (*PFNEGLCREATESTREAMATTRIBNV)(EGLDisplay, EGLAttrib *);
43​typedef EGLBoolean (*PFNEGLGETOUTPUTLAYERSEXT)(EGLDisplay, EGLAttrib *, EGLOutputLayerEXT *, EGLint, EGLint *);
44​typedef EGLBoolean (*PFNEGLSTREAMCONSUMEROUTPUTEXT)(EGLDisplay, EGLStreamKHR, EGLOutputLayerEXT);
45​typedef EGLSurface (*PFNEGLCREATESTREAMPRODUCERSURFACEKHR)(EGLDisplay, EGLConfig, EGLStreamKHR, EGLint *);
46​typedef EGLBoolean (*PFNEGLDESTROYSTREAMKHR)(EGLDisplay, EGLStreamKHR);
47​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLAttrib *);
48​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)(EGLDisplay, EGLStreamKHR);
49​typedef EGLBoolean (*PFNEGLQUERYSTREAMATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLenum, EGLAttrib *);
50​typedef EGLBoolean (*PFNEGLSTREAMCONSUMERRELEASEKHR)(EGLDisplay, EGLStreamKHR);
51​PFNEGLCREATESTREAMATTRIBNV pEglCreateStreamAttribNV = nullptr;
52​PFNEGLGETOUTPUTLAYERSEXT pEglGetOutputLayersEXT = nullptr;
53​PFNEGLSTREAMCONSUMEROUTPUTEXT pEglStreamConsumerOutputEXT = nullptr;
54​PFNEGLCREATESTREAMPRODUCERSURFACEKHR pEglCreateStreamProducerSurfaceKHR = nullptr;
55​PFNEGLDESTROYSTREAMKHR pEglDestroyStreamKHR = nullptr;
56​PFNEGLSTREAMCONSUMERACQUIREATTRIBNV pEglStreamConsumerAcquireAttribNV = nullptr;
57​PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR pEglStreamConsumerGLTextureExternalKHR = nullptr;
58​PFNEGLQUERYSTREAMATTRIBNV pEglQueryStreamAttribNV = nullptr;
59​PFNEGLSTREAMCONSUMERRELEASEKHR pEglStreamConsumerReleaseKHR = nullptr;
60​
61​#ifndef EGL_CONSUMER_AUTO_ACQUIRE_EXT
62​#define EGL_CONSUMER_AUTO_ACQUIRE_EXT 0x332B
63​#endif
64​
65​#ifndef EGL_DRM_MASTER_FD_EXT
66​#define EGL_DRM_MASTER_FD_EXT 0x333C
67​#endif
68​
69​#ifndef EGL_DRM_FLIP_EVENT_DATA_NV
70​#define EGL_DRM_FLIP_EVENT_DATA_NV 0x333E
71​#endif
72​
73​#ifndef EGL_WAYLAND_EGLSTREAM_WL
74​#define EGL_WAYLAND_EGLSTREAM_WL 0x334B
75​#endif
76​
77​#ifndef EGL_WAYLAND_Y_INVERTED_WL
78​#define EGL_WAYLAND_Y_INVERTED_WL 0x31DB
79​#endif
80​
81​EglStreamBackend::EglStreamBackend(DrmBackend *b)
82​ : AbstractEglBackend(), m_backend(b)
83​{
84​ setIsDirectRendering(true);
85​ setSyncsToVBlank(true);
86​ connect(m_backend, &DrmBackend::outputAdded, this, &EglStreamBackend::createOutput);
87​ connect(m_backend, &DrmBackend::outputRemoved, this,
88​ [this] (DrmOutput *output) {
89​ auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
90​ [output] (const Output &o) {
91​ return o.output == output;
92​ });
93​ if (it == m_outputs.end()) {
94​ return;
95​ }
96​ cleanupOutput(*it);
97​ m_outputs.erase(it);
98​ });
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…
99​}
100​
101​EglStreamBackend::~EglStreamBackend()
102​{
103​ cleanup();
104​}
105​
106​void EglStreamBackend::cleanupSurfaces()
107​{
108​ for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
109​ cleanupOutput(*it);
110​ }
111​ m_outputs.clear();
112​}
113​
114​void EglStreamBackend::cleanupOutput(const Output &o)
115​{
116​ if (o.eglSurface != EGL_NO_SURFACE) {
117​ eglDestroySurface(eglDisplay(), o.eglSurface);
118​ }
119​ if (o.eglStream != EGL_NO_STREAM_KHR) {
120​ pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
121​ }
122​}
123​
124​bool EglStreamBackend::initializeEgl()
125​{
126​ initClientExtensions();
127​ EGLDisplay display = m_backend->sceneEglDisplay();
128​ if (display == EGL_NO_DISPLAY) {
129​ if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_device_base")) &&
130​ !(hasClientExtension(QByteArrayLiteral("EGL_EXT_device_query")) &&
131​ hasClientExtension(QByteArrayLiteral("EGL_EXT_device_enumeration")))) {
132​ setFailed("Missing required EGL client extension: "
133​ "EGL_EXT_device_base or "
134​ "EGL_EXT_device_query and EGL_EXT_device_enumeration");
135​ return false;
136​ }
137​
138​ // Try to find the EGLDevice corresponding to our DRM device file
139​ int numDevices;
140​ eglQueryDevicesEXT(0, nullptr, &numDevices);
141​ QVector<EGLDeviceEXT> devices(numDevices);
142​ eglQueryDevicesEXT(numDevices, devices.data(), &numDevices);
143​ for (EGLDeviceEXT device : devices) {
144​ const char *drmDeviceFile = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
145​ if (m_backend->devNode() != drmDeviceFile) {
146​ continue;
147​ }
148​
149​ const char *deviceExtensionCString = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
150​ QByteArray deviceExtensions = QByteArray::fromRawData(deviceExtensionCString,
151​ qstrlen(deviceExtensionCString));
152​ if (!deviceExtensions.split(' ').contains(QByteArrayLiteral("EGL_EXT_device_drm"))) {
153​ continue;
154​ }
155​
156​ EGLint platformAttribs[] = {
157​ EGL_DRM_MASTER_FD_EXT, m_backend->fd(),
158​ EGL_NONE
159​ };
160​ display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, platformAttribs);
161​ break;
162​ }
163​ }
164​
165​ if (display == EGL_NO_DISPLAY) {
166​ setFailed("No suitable EGL device found");
167​ return false;
168​ }
169​
170​ setEglDisplay(display);
171​ if (!initEglAPI()) {
172​ return false;
173​ }
174​
175​ const QVector<QByteArray> requiredExtensions = {
176​ QByteArrayLiteral("EGL_EXT_output_base"),
177​ QByteArrayLiteral("EGL_EXT_output_drm"),
178​ QByteArrayLiteral("EGL_KHR_stream"),
179​ QByteArrayLiteral("EGL_KHR_stream_producer_eglsurface"),
180​ QByteArrayLiteral("EGL_EXT_stream_consumer_egloutput"),
181​ QByteArrayLiteral("EGL_NV_stream_attrib"),
182​ QByteArrayLiteral("EGL_EXT_stream_acquire_mode"),
183​ QByteArrayLiteral("EGL_KHR_stream_consumer_gltexture"),
184​ QByteArrayLiteral("EGL_WL_wayland_eglstream")
185​ };
186​ for (const QByteArray &ext : requiredExtensions) {
187​ if (!hasExtension(ext)) {
188​ setFailed(QStringLiteral("Missing required EGL extension: ") + ext);
189​ return false;
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​ }
191​ }
192​
193​ pEglCreateStreamAttribNV = (PFNEGLCREATESTREAMATTRIBNV)eglGetProcAddress("eglCreateStreamAttribNV");
194​ pEglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXT)eglGetProcAddress("eglGetOutputLayersEXT");
195​ pEglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXT)eglGetProcAddress("eglStreamConsumerOutputEXT");
196​ pEglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHR)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
197​ pEglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHR)eglGetProcAddress("eglDestroyStreamKHR");
198​ pEglStreamConsumerAcquireAttribNV = (PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)eglGetProcAddress("eglStreamConsumerAcquireAttribNV");
199​ pEglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR");
200​ pEglQueryStreamAttribNV = (PFNEGLQUERYSTREAMATTRIBNV)eglGetProcAddress("eglQueryStreamAttribNV");
201​ pEglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHR)eglGetProcAddress("eglStreamConsumerReleaseKHR");
202​ return true;
203​}
204​
205​struct StreamTexture {
206​ EGLStreamKHR stream;
207​ GLuint textures[2];
208​ bool swap;
209​};
210​QHash<wl_resource *, StreamTexture> surfaceTextures;
211​
212​static void attachEglStreamConsumer(wl_client *client,
213​ wl_resource *resource,
214​ wl_resource *wl_surface,
215​ wl_resource *wl_eglstream)
216​{
217​ Q_UNUSED(client);
218​ Q_UNUSED(resource);
219​
220​ EGLDisplay eglDisplay = waylandServer()->display()->eglDisplay();
221​ EGLAttrib streamAttribs[] = {
222​ EGL_WAYLAND_EGLSTREAM_WL, (EGLAttrib)wl_eglstream,
223​ EGL_NONE
224​ };
225​ EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay, streamAttribs);
226​ if (stream == EGL_NO_STREAM_KHR) {
227​ qCWarning(KWIN_DRM) << "Failed to create EGL stream";
228​ return;
229​ }
230​
231​ GLuint texture;
232​ auto it = surfaceTextures.find(wl_surface);
233​ using namespace KWayland::Server;
234​ SurfaceInterface *surface = SurfaceInterface::get(wl_surface);
235​ if (it != surfaceTextures.end()) {
236​ StreamTexture &st = it.value();
237​ pEglDestroyStreamKHR(eglDisplay, st.stream);
238​ st.stream = stream;
239​ st.swap = true;
240​ texture = st.textures[1];
241​ } else {
242​ StreamTexture st = { stream, { 0, 0 }, false };
243​ glGenTextures(2, st.textures);
244​ surfaceTextures.insert(wl_surface, st);
245​ texture = st.textures[0];
246​
247​ QObject::connect(surface, &Resource::unbound,
248​ [wl_surface, eglDisplay]() {
249​ const StreamTexture &st = surfaceTextures.take(wl_surface);
250​ pEglDestroyStreamKHR(eglDisplay, st.stream);
251​ glDeleteTextures(2, st.textures);
252​ });
253​ }
254​
255​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
256​ if (!pEglStreamConsumerGLTextureExternalKHR(eglDisplay, stream)) {
257​ qCWarning(KWIN_DRM) << "Failed to bind EGL stream to texture";
258​ }
259​ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
260​}
261​
262​const struct {
263​ void (*f)(wl_client *, wl_resource *, wl_resource *, wl_resource *);
264​} eglStreamControllerImplementation = {
265​ attachEglStreamConsumer
266​};
267​const wl_interface *eglStreamControllerInterface;
268​
269​static void bindEglStreamController(wl_client *client,
270​ void *data, uint32_t version, uint32_t id)
271​{
272​ wl_resource *resource = wl_resource_create(client, eglStreamControllerInterface,
273​ version, id);
274​ if (!resource) {
275​ wl_client_post_no_memory(client);
zzagUnsubmitted
Done

Missing return?

zzag: Missing return?
276​ }
277​ wl_resource_set_implementation(resource, (void *)&eglStreamControllerImplementation,
278​ data, NULL);
zzagUnsubmitted
Done

Please use nullptr.

zzag: Please use nullptr.
279​}
280​
281​void EglStreamBackend::init()
282​{
283​ if (!initializeEgl()) {
284​ setFailed("Failed to initialize EGL api");
285​ return;
286​ }
287​ if (!initRenderingContext()) {
288​ setFailed("Failed to initialize rendering context");
289​ return;
290​ }
291​
292​ initKWinGL();
293​ setSupportsBufferAge(false);
294​ initWayland();
295​
296​ // libnvidia-egl-wayland.so.1 may not be present on all systems,
297​ // so we load it dynamically
298​ void *lib = dlopen("libnvidia-egl-wayland.so.1", RTLD_NOW | RTLD_LAZY);
299​ if (!lib) {
300​ goto fail;
zzagUnsubmitted
Done

Please no goto. Use a lambda.

zzag: Please no `goto`. Use a lambda.
301​ }
302​ eglStreamControllerInterface = (wl_interface *)dlsym(lib, "wl_eglstream_controller_interface");
303​ if (!eglStreamControllerInterface) {
304​ goto fail;
305​ }
306​ if (wl_global_create(*waylandServer()->display(),
307​ eglStreamControllerInterface,
308​ 1, NULL, bindEglStreamController)) {
309​ return;
310​ }
311​
312​fail:
313​ if (lib) {
314​ dlclose(lib);
315​ }
316​ setFailed("Failed to initialize wl_eglstream_controller interface");
317​}
318​
319​bool EglStreamBackend::initRenderingContext()
320​{
321​ initBufferConfigs();
322​
323​ if (!createContext()) {
324​ return false;
325​ }
cfeckUnsubmitted
Done

Space before :

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

To reduce indent, do instead:

if (!resetOutput(o, drmOutput)) {
    return;
}
...
romangg: To reduce indent, do instead: ``` if (!resetOutput(o, drmOutput)) { return; } ... ```
405​ connect(drmOutput, &DrmOutput::modeChanged, this,
406​ [drmOutput, this] {
407​ auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
408​ [drmOutput] (const auto &o) {
409​ return o.output == drmOutput;
410​ }
411​ );
412​ if (it == m_outputs.end()) {
413​ return;
414​ }
415​ resetOutput(*it, drmOutput);
416​ }
417​ );
418​ m_outputs << o;
419​ }
420​}
421​
422​bool EglStreamBackend::makeContextCurrent(const Output &output)
423​{
424​ const EGLSurface surface = output.eglSurface;
425​ if (surface == EGL_NO_SURFACE) {
426​ return false;
427​ }
428​
429​ if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
430​ qCCritical(KWIN_DRM) << "Failed to make EGL context current";
431​ return false;
432​ }
433​
434​ EGLint error = eglGetError();
435​ if (error != EGL_SUCCESS) {
436​ qCWarning(KWIN_DRM) << "Error occurred while making EGL context current" << error;
437​ return false;
438​ }
439​
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​ const QSize &overall = screens()->size();
441​ const QRect &v = output.output->geometry();
442​ qreal scale = output.output->scale();
443​ glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
444​ overall.width() * scale, overall.height() * scale);
445​ return true;
446​}
447​
448​bool EglStreamBackend::initBufferConfigs()
449​{
450​ const EGLint configAttribs[] = {
451​ EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR,
452​ EGL_RED_SIZE, 1,
453​ EGL_GREEN_SIZE, 1,
454​ EGL_BLUE_SIZE, 1,
455​ EGL_ALPHA_SIZE, 0,
456​ EGL_RENDERABLE_TYPE, isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
457​ EGL_CONFIG_CAVEAT, EGL_NONE,
458​ EGL_NONE,
459​ };
460​ EGLint count;
461​ EGLConfig config;
462​ if (!eglChooseConfig(eglDisplay(), configAttribs, &config, 1, &count)) {
463​ qCCritical(KWIN_DRM) << "Failed to query available EGL configs";
464​ return false;
465​ }
466​ if (count == 0) {
467​ qCCritical(KWIN_DRM) << "No suitable EGL config found";
468​ return false;
469​ }
470​
471​ setConfig(config);
472​ return true;
473​}
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.
474​
475​void EglStreamBackend::present()
476​{
cfeckUnsubmitted
Done

Space

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