Implement wl_eglstream_controller Server Interface

Summary:
This implements a wrapper class for the wl_eglstream_controller Wayland
interface. It allows clients to inform the compositor when a new EGL Stream has
been created with an Wayland surface attached as its producer. The compositor
can then bind a GL texture as the stream's consumer allowing it access to the
surface's buffer contents for presentation. The only client currently expected
to make use of this interface is the NVIDIA EGL driver when running alongside a
compositor supporting EGLStream-based buffer sharing.

Reviewers: #kwin, romangg, davidedmundson

Reviewed By: #kwin, romangg, davidedmundson

Subscribers: kde-frameworks-devel

Tage: #frameworks

Differential Revision: https://phabricator.kde.org/D18824
master
Erik Kurzinger 6 years ago
parent 6dd0e17759
commit 840268aa7e

@ -58,6 +58,7 @@ set(SERVER_LIB_SRCS
xdgshell_v6_interface.cpp
xdgshell_stable_interface.cpp
xdgoutput_interface.cpp
eglstream_controller_interface.cpp
../compat/wayland-xdg-shell-v5-protocol.c
)
@ -202,6 +203,11 @@ ecm_add_wayland_server_protocol(SERVER_LIB_SRCS
BASENAME xdg-decoration
)
ecm_add_wayland_server_protocol(SERVER_LIB_SRCS
PROTOCOL ${KWayland_SOURCE_DIR}/src/client/protocols/wayland-eglstream-controller.xml
BASENAME eglstream-controller
)
set(SERVER_GENERATED_SRCS
${CMAKE_CURRENT_BINARY_DIR}/wayland-output-management-client-protocol.h
${CMAKE_CURRENT_BINARY_DIR}/wayland-output-management-server-protocol.h
@ -257,6 +263,7 @@ set(SERVER_GENERATED_SRCS
${CMAKE_CURRENT_BINARY_DIR}/wayland-output-unstable-v1-client-protocol.h
${CMAKE_CURRENT_BINARY_DIR}/wayland-xdg-decoration-server-protocol.h
${CMAKE_CURRENT_BINARY_DIR}/wayland-xdg-decoration-client-protocol.h
${CMAKE_CURRENT_BINARY_DIR}/wayland-eglstream-controller-server-protocol.h
)
set_source_files_properties(${SERVER_GENERATED_SRCS} PROPERTIES SKIP_AUTOMOC ON)
@ -303,6 +310,7 @@ set(SERVER_LIB_HEADERS
datasource_interface.h
display.h
dpms_interface.h
eglstream_controller_interface.h
filtered_display.h
fakeinput_interface.h
global.h

@ -55,6 +55,7 @@ License along with this library. If not, see <http://www.gnu.org/licenses/>.
#include "plasmavirtualdesktop_interface.h"
#include "xdgoutput_interface.h"
#include "xdgdecoration_interface.h"
#include "eglstream_controller_interface.h"
#include <QCoreApplication>
#include <QDebug>
@ -514,6 +515,13 @@ XdgDecorationManagerInterface *Display::createXdgDecorationManager(XdgShellInter
return d;
}
EglStreamControllerInterface *Display::createEglStreamControllerInterface(QObject *parent)
{
EglStreamControllerInterface *e = new EglStreamControllerInterface(this, parent);
connect(this, &Display::aboutToTerminate, e, [e] { delete e; });
return e;
}
void Display::createShm()
{
Q_ASSERT(d->display);

@ -90,6 +90,7 @@ class ServerSideDecorationPaletteManagerInterface;
class PlasmaVirtualDesktopManagementInterface;
class XdgOutputManagerInterface;
class XdgDecorationManagerInterface;
class EglStreamControllerInterface;
/**
* @brief Class holding the Wayland server display loop.
@ -302,6 +303,14 @@ public:
*/
XdgDecorationManagerInterface *createXdgDecorationManager(XdgShellInterface *shellInterface, QObject *parent = nullptr);
/**
* Creates the EglStreamControllerInterface
*
* @return the created EGL Stream controller
* @since 5.58
*/
EglStreamControllerInterface *createEglStreamControllerInterface(QObject *parent = nullptr);
/**
* Gets the ClientConnection for the given @p client.
* If there is no ClientConnection yet for the given @p client, it will be created.

@ -0,0 +1,107 @@
/****************************************************************************
Copyright 2019 NVIDIA Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "eglstream_controller_interface_p.h"
#include "clientconnection.h"
#include "display.h"
#include "logging.h"
#include <wayland-util.h>
#include <QLibrary>
namespace KWayland
{
namespace Server
{
const quint32 EglStreamControllerInterface::Private::s_version = 1;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
const struct wl_eglstream_controller_interface EglStreamControllerInterface::Private::s_interface = {
attachStreamConsumer,
attachStreamConsumerAttribs
};
#endif
void EglStreamControllerInterface::Private::attachStreamConsumer(wl_client *client,
wl_resource *resource,
wl_resource *surface,
wl_resource *eglStream)
{
wl_array noAttribs = { 0, 0, nullptr };
attachStreamConsumerAttribs(client, resource, surface, eglStream, &noAttribs);
}
void EglStreamControllerInterface::Private::attachStreamConsumerAttribs(wl_client *client,
wl_resource *resource,
wl_resource *surface,
wl_resource *eglStream,
wl_array *attribs)
{
Q_UNUSED(client);
Private *p = reinterpret_cast<Private *>(wl_resource_get_user_data(resource));
emit p->q->streamConsumerAttached(SurfaceInterface::get(surface), eglStream, attribs);
}
EglStreamControllerInterface::Private::Private(EglStreamControllerInterface *q, Display *display)
// libnvidia-egl-wayland.so.1 may not be present on all systems, so we load it dynamically
: Global::Private(display,
(wl_interface *)QLibrary::resolve(QLatin1String("libnvidia-egl-wayland.so.1"),
"wl_eglstream_controller_interface"),
s_version)
, q(q)
{
}
void EglStreamControllerInterface::Private::create()
{
// bail out early if we were unable to load the interface
if (m_interface == nullptr) {
qCWarning(KWAYLAND_SERVER) << "failed to resolve wl_eglstream_controller_interface";
return;
}
Global::Private::create();
}
void EglStreamControllerInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
{
wl_resource *r = display->getConnection(client)->createResource(m_interface, version, id);
if (r == nullptr) {
wl_client_post_no_memory(client);
return;
}
wl_resource_set_implementation(r, &s_interface, this, nullptr);
}
EglStreamControllerInterface::~EglStreamControllerInterface() = default;
EglStreamControllerInterface::EglStreamControllerInterface(Display *display, QObject *parent)
: Global(new Private(this, display), parent)
{
}
void EglStreamControllerInterface::create()
{
static_cast<Private &>(*d).create();
}
}
}

@ -0,0 +1,67 @@
/****************************************************************************
Copyright 2019 NVIDIA Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#ifndef WAYLAND_SERVER_EGLSTREAM_CONTROLLER_INTERFACE_H
#define WAYLAND_SERVER_EGLSTREAM_CONTROLLER_INTERFACE_H
#include "global.h"
#include "surface_interface.h"
#include <KWayland/Server/kwaylandserver_export.h>
#include <wayland-util.h>
#include <QObject>
namespace KWayland
{
namespace Server
{
class Display;
/**
* @brief Represents the Global for the wl_eglstream_controller interface.
*
* This class handles requests (typically from the NVIDIA EGL driver) to attach
* a newly created EGL Stream to a Wayland surface, facilitating the sharing
* of buffer contents between client and compositor.
*
*/
class KWAYLANDSERVER_EXPORT EglStreamControllerInterface : public Global
{
Q_OBJECT
public:
~EglStreamControllerInterface() override;
void create();
Q_SIGNALS:
/**
* Emitted when a new stream attach request is received.
*/
void streamConsumerAttached(SurfaceInterface *surface, void *eglStream, wl_array *attribs);
private:
explicit EglStreamControllerInterface(Display *display, QObject *parent = nullptr);
class Private;
friend class Display;
};
}
}
#endif

@ -0,0 +1,58 @@
/****************************************************************************
Copyright 2019 NVIDIA Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#ifndef WAYLAND_SERVER_EGLSTREAM_CONTROLLER_INTERFACE_P_H
#define WAYLAND_SERVER_EGLSTREAM_CONTROLLER_INTERFACE_P_H
#include "eglstream_controller_interface.h"
#include "global_p.h"
#include <wayland-eglstream-controller-server-protocol.h>
namespace KWayland
{
namespace Server
{
class Q_DECL_HIDDEN EglStreamControllerInterface::Private : public Global::Private
{
public:
Private(EglStreamControllerInterface *controller, Display *display);
void create();
private:
static void attachStreamConsumer(wl_client *client,
wl_resource *resource,
wl_resource *surface,
wl_resource *eglStream);
static void attachStreamConsumerAttribs(wl_client *client,
wl_resource *resource,
wl_resource *surface,
wl_resource *eglStream,
wl_array *attribs);
static const struct wl_eglstream_controller_interface s_interface;
static const quint32 s_version;
void bind(wl_client *client, uint32_t version, uint32_t id) override;
EglStreamControllerInterface *q;
};
}
}
#endif
Loading…
Cancel
Save