c898f96df3
Summary:
This is the initial implementation of a DRM backend based on the EGLDevice,
EGLOutput, and EGLStream extensions, supporting NVIDIA graphics hardware using
their proprietary driver. The new backend will be used if the environment
variable KWIN_DRM_USE_EGL_STREAMS is set. On initialization, it will attempt to
create an EGLDevice based on the DRM device currently in use and create
EGLOutputs and EGLStreams for any attached displays. These are used to control
presentation of the final composited frame. Additionally, it will register the
wl_eglstream_controller Wayland interface so that native EGL windows created by
clients can be attached to an EGLStream allowing buffer contents to be shared
with the compositor as a GL texture.
At this time there are two known bugs in the NVIDIA driver's EGL implementation
affecting desktop functionality. The first can result in tooltip windows drawn
by plasmashell to contain incorrect contents. The second prevents KWayland from
being able to query the format of EGLStream-backed buffers which interferes
with the blur effect. Fixes for both of these are currently in development and
should appear in an upcoming NVIDIA driver release.
Additionally, hardware cursors are currently not supported with this backend.
Enabling them causes the desktop to intermittently hang for several seconds.
This is also likely a bug in the NVIDIA DRM-KMS implementation but the root
cause is still under investigation.
Test Plan:
On a system with an NVIDIA graphics card running a recent release of their
proprietary driver
* Ensure the nvidia_drm kernel module is loaded with the option "modeset=1"
("# cat /sys/module/nvidia_drm/parameters/modeset" should print "Y")
* Ensure EGL external platform support is installed
https://github.com/NVIDIA/eglexternalplatform
* Ensure KWin was build with the CMake option
KWIN_BUILD_EGL_STREAM_BACKEND=ON (this is the default)
* Start a plasma wayland session with the environment variable
KWIN_DRM_USE_EGL_STREAMS set
* Ensure output from KWin OpenGL initialization indicates the NVIDIA EGL
driver is in use (as opposed to Mesa / llvmpipe).
* Desktop should be fully functional and perform smoothly.
Reviewers: #kwin, romangg, davidedmundson
Reviewed By: #kwin, romangg, davidedmundson
Subscribers: kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18570
116 lines
3.8 KiB
C++
116 lines
3.8 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2019 NVIDIA Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*********************************************************************/
|
|
#ifndef KWIN_EGL_STREAM_BACKEND_H
|
|
#define KWIN_EGL_STREAM_BACKEND_H
|
|
#include "abstract_egl_backend.h"
|
|
#include <KWayland/Server/surface_interface.h>
|
|
#include <KWayland/Server/eglstream_controller_interface.h>
|
|
#include <wayland-server-core.h>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
class DrmBackend;
|
|
class DrmOutput;
|
|
class DrmBuffer;
|
|
class ShellClient;
|
|
|
|
/**
|
|
* @brief OpenGL Backend using Egl with an EGLDevice.
|
|
**/
|
|
class EglStreamBackend : public AbstractEglBackend
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
EglStreamBackend(DrmBackend *b);
|
|
virtual ~EglStreamBackend();
|
|
void screenGeometryChanged(const QSize &size) override;
|
|
SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) override;
|
|
QRegion prepareRenderingFrame() override;
|
|
void endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion) override;
|
|
void endRenderingFrameForScreen(int screenId, const QRegion &damage, const QRegion &damagedRegion) override;
|
|
bool usesOverlayWindow() const override;
|
|
bool perScreenRendering() const override;
|
|
QRegion prepareRenderingForScreen(int screenId) override;
|
|
void init() override;
|
|
|
|
protected:
|
|
void present() override;
|
|
void cleanupSurfaces() override;
|
|
|
|
private:
|
|
bool initializeEgl();
|
|
bool initBufferConfigs();
|
|
bool initRenderingContext();
|
|
struct StreamTexture
|
|
{
|
|
EGLStreamKHR stream;
|
|
GLuint texture;
|
|
};
|
|
StreamTexture *lookupStreamTexture(KWayland::Server::SurfaceInterface *surface);
|
|
void attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
|
|
void *eglStream,
|
|
wl_array *attribs);
|
|
struct Output
|
|
{
|
|
DrmOutput *output = nullptr;
|
|
DrmBuffer *buffer = nullptr;
|
|
EGLSurface eglSurface = EGL_NO_SURFACE;
|
|
EGLStreamKHR eglStream = EGL_NO_STREAM_KHR;
|
|
};
|
|
bool resetOutput(Output &output, DrmOutput *drmOutput);
|
|
bool makeContextCurrent(const Output &output);
|
|
void presentOnOutput(Output &output);
|
|
void cleanupOutput(const Output &output);
|
|
void createOutput(DrmOutput *output);
|
|
|
|
DrmBackend *m_backend;
|
|
QVector<Output> m_outputs;
|
|
KWayland::Server::EglStreamControllerInterface *m_eglStreamControllerInterface;
|
|
QHash<KWayland::Server::SurfaceInterface *, StreamTexture> m_streamTextures;
|
|
|
|
friend class EglStreamTexture;
|
|
};
|
|
|
|
/**
|
|
* @brief External texture bound to an EGLStreamKHR.
|
|
**/
|
|
class EglStreamTexture : public AbstractEglTexture
|
|
{
|
|
public:
|
|
virtual ~EglStreamTexture();
|
|
bool loadTexture(WindowPixmap *pixmap) override;
|
|
void updateTexture(WindowPixmap *pixmap) override;
|
|
|
|
private:
|
|
EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend);
|
|
bool acquireStreamFrame(EGLStreamKHR stream);
|
|
void createFbo();
|
|
void copyExternalTexture(GLuint tex);
|
|
bool attachBuffer(KWayland::Server::BufferInterface *buffer);
|
|
EglStreamBackend *m_backend;
|
|
GLuint m_fbo, m_rbo;
|
|
GLenum m_format;
|
|
friend class EglStreamBackend;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif
|