diff --git a/CMakeLists.txt b/CMakeLists.txt --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,7 +9,7 @@ ################# set KDE specific information ################# find_package(ECM 1.3.0 REQUIRED NO_MODULE) -set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR}) +set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules") include(KDEInstallDirs) include(KDECMakeSettings) @@ -19,6 +19,27 @@ include(ECMOptionalAddSubdirectory) include(FeatureSummary) +include(FindPkgConfig) + +# remove? +pkg_check_modules(PIPEWIRE REQUIRED libpipewire-0.1) +pkg_check_modules(SPA REQUIRED libspa-0.1) +pkg_check_modules(GLIB REQUIRED glib-2.0) + +find_package(gbm REQUIRED) +set_package_properties(gbm PROPERTIES DESCRIPTION "GBM - Generic Buffer Management" + TYPE REQUIRED + PURPOSE "Required for egl ouput of drm backend." +) + +find_package(epoxy REQUIRED) +include_directories(${epoxy_INCLUDE_DIRS}) +set_package_properties(epoxy PROPERTIES DESCRIPTION "libepoxy" + URL "http://github.com/anholt/libepoxy" + TYPE REQUIRED + PURPOSE "OpenGL dispatch library for GBM backend" +) + find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS Core DBus @@ -30,9 +51,10 @@ CoreAddons I18n Notifications + Wayland ) -add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_NO_KEYWORDS) +add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0) add_definitions(-DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS) remove_definitions(-DQT_NO_CAST_FROM_ASCII -DQT_STRICT_ITERATORS -DQT_NO_CAST_FROM_BYTEARRAY) diff --git a/cmake/modules/Findepoxy.cmake b/cmake/modules/Findepoxy.cmake new file mode 100644 --- /dev/null +++ b/cmake/modules/Findepoxy.cmake @@ -0,0 +1,56 @@ +# - Try to find libepoxy +# Once done this will define +# +# epoxy_FOUND - System has libepoxy +# epoxy_LIBRARY - The libepoxy library +# epoxy_INCLUDE_DIR - The libepoxy include dir +# epoxy_DEFINITIONS - Compiler switches required for using libepoxy +# epoxy_HAS_GLX - Whether GLX support is available + +# Copyright (c) 2014 Fredrik Höglund +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +# SUCH DAMAGE. + +if (NOT WIN32) + find_package(PkgConfig) + pkg_check_modules(PKG_epoxy QUIET epoxy) + + set(epoxy_DEFINITIONS ${PKG_epoxy_CFLAGS}) + + find_path(epoxy_INCLUDE_DIR NAMES epoxy/gl.h HINTS ${PKG_epoxy_INCLUDEDIR} ${PKG_epoxy_INCLUDE_DIRS}) + find_library(epoxy_LIBRARY NAMES epoxy HINTS ${PKG_epoxy_LIBDIR} ${PKG_epoxy_LIBRARY_DIRS}) + find_file(epoxy_GLX_HEADER NAMES epoxy/glx.h HINTS ${epoxy_INCLUDE_DIR}) + + if (epoxy_GLX_HEADER STREQUAL "epoxy_GLX_HEADER-NOTFOUND") + set(epoxy_HAS_GLX FALSE CACHE BOOL "whether glx is available") + else () + set(epoxy_HAS_GLX TRUE CACHE BOOL "whether glx is available") + endif() + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(epoxy DEFAULT_MSG epoxy_LIBRARY epoxy_INCLUDE_DIR) + + mark_as_advanced(epoxy_INCLUDE_DIR epoxy_LIBRARY epoxy_HAS_GLX) +endif() diff --git a/cmake/modules/Findgbm.cmake b/cmake/modules/Findgbm.cmake new file mode 100644 --- /dev/null +++ b/cmake/modules/Findgbm.cmake @@ -0,0 +1,125 @@ +#.rst: +# Findgbm +# ------- +# +# Try to find gbm on a Unix system. +# +# This will define the following variables: +# +# ``gbm_FOUND`` +# True if (the requested version of) gbm is available +# ``gbm_VERSION`` +# The version of gbm +# ``gbm_LIBRARIES`` +# This can be passed to target_link_libraries() instead of the ``gbm::gbm`` +# target +# ``gbm_INCLUDE_DIRS`` +# This should be passed to target_include_directories() if the target is not +# used for linking +# ``gbm_DEFINITIONS`` +# This should be passed to target_compile_options() if the target is not +# used for linking +# +# If ``gbm_FOUND`` is TRUE, it will also define the following imported target: +# +# ``gbm::gbm`` +# The gbm library +# +# In general we recommend using the imported target, as it is easier to use. +# Bear in mind, however, that if the target is in the link interface of an +# exported library, it must be made available by the package config file. + +#============================================================================= +# Copyright 2014 Alex Merry +# Copyright 2014 Martin Gräßlin +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#============================================================================= + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "CMake 2.8.12 is required by Findgbm.cmake") +endif() +if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.12) + message(AUTHOR_WARNING "Your project should require at least CMake 2.8.12 to use Findgbm.cmake") +endif() + +if(NOT WIN32) + # Use pkg-config to get the directories and then use these values + # in the FIND_PATH() and FIND_LIBRARY() calls + find_package(PkgConfig) + pkg_check_modules(PKG_gbm QUIET gbm) + + set(gbm_DEFINITIONS ${PKG_gbm_CFLAGS_OTHER}) + set(gbm_VERSION ${PKG_gbm_VERSION}) + + find_path(gbm_INCLUDE_DIR + NAMES + gbm.h + HINTS + ${PKG_gbm_INCLUDE_DIRS} + ) + find_library(gbm_LIBRARY + NAMES + gbm + HINTS + ${PKG_gbm_LIBRARY_DIRS} + ) + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(gbm + FOUND_VAR + gbm_FOUND + REQUIRED_VARS + gbm_LIBRARY + gbm_INCLUDE_DIR + VERSION_VAR + gbm_VERSION + ) + + if(gbm_FOUND AND NOT TARGET gbm::gbm) + add_library(gbm::gbm UNKNOWN IMPORTED) + set_target_properties(gbm::gbm PROPERTIES + IMPORTED_LOCATION "${gbm_LIBRARY}" + INTERFACE_COMPILE_OPTIONS "${gbm_DEFINITIONS}" + INTERFACE_INCLUDE_DIRECTORIES "${gbm_INCLUDE_DIR}" + ) + endif() + + mark_as_advanced(gbm_LIBRARY gbm_INCLUDE_DIR) + + # compatibility variables + set(gbm_LIBRARIES ${gbm_LIBRARY}) + set(gbm_INCLUDE_DIRS ${gbm_INCLUDE_DIR}) + set(gbm_VERSION_STRING ${gbm_VERSION}) + +else() + message(STATUS "Findgbm.cmake cannot find gbm on Windows systems.") + set(gbm_FOUND FALSE) +endif() + +include(FeatureSummary) +set_package_properties(gbm PROPERTIES + URL "http://www.mesa3d.org" + DESCRIPTION "Mesa gbm library." +) diff --git a/data/kde.portal b/data/kde.portal --- a/data/kde.portal +++ b/data/kde.portal @@ -1,4 +1,4 @@ [portal] DBusName=org.freedesktop.impl.portal.desktop.kde -Interfaces=org.freedesktop.impl.portal.Access;org.freedesktop.impl.portal.AppChooser;org.freedesktop.impl.portal.Email;org.freedesktop.impl.portal.FileChooser;org.freedesktop.impl.portal.Inhibit;org.freedesktop.impl.portal.Notification;org.freedesktop.impl.portal.Print +Interfaces=org.freedesktop.impl.portal.Access;org.freedesktop.impl.portal.AppChooser;org.freedesktop.impl.portal.Email;org.freedesktop.impl.portal.FileChooser;org.freedesktop.impl.portal.Inhibit;org.freedesktop.impl.portal.Notification;org.freedesktop.impl.portal.Print;org.freedesktop.impl.portal.ScreenCast UseIn=KDE diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,6 +2,8 @@ include_directories( ${Qt5PrintSupport_PRIVATE_INCLUDE_DIRS} + ${PIPEWIRE_INCLUDE_DIRS} ${SPA_INCLUDE_DIRS} ${GLIB_INCLUDE_DIRS} + ${gbm_INCLUDE_DIRS} ) set(xdg_desktop_portal_kde_SRCS @@ -17,11 +19,16 @@ notification.cpp print.cpp request.cpp + screencast.cpp + screencaststream.cpp + screenchooserdialog.cpp + session.cpp ) ki18n_wrap_ui(xdg_desktop_portal_kde_SRCS accessdialog.ui appchooserdialog.ui + screenchooserdialog.ui ) add_executable(xdg-desktop-portal-kde ${xdg_desktop_portal_kde_SRCS}) @@ -34,6 +41,12 @@ KF5::CoreAddons KF5::I18n KF5::Notifications + KF5::WaylandClient + ${PIPEWIRE_LIBRARIES} + ${SPA_LIBRARIES} + ${GLIB_LIBRARIES} + ${epoxy_LIBRARY} + gbm::gbm ) install(TARGETS xdg-desktop-portal-kde DESTINATION ${KDE_INSTALL_LIBEXECDIR}) diff --git a/src/access.cpp b/src/access.cpp --- a/src/access.cpp +++ b/src/access.cpp @@ -24,7 +24,7 @@ #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAccess, "xdg-desktop-portal-kde-access") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAccess, "xdp-kde-access") AccessPortal::AccessPortal(QObject *parent) : QDBusAbstractAdaptor(parent) diff --git a/src/accessdialog.cpp b/src/accessdialog.cpp --- a/src/accessdialog.cpp +++ b/src/accessdialog.cpp @@ -26,7 +26,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAccessDialog, "xdg-desktop-portal-kde-access-dialog") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAccessDialog, "xdp-kde-access-dialog") AccessDialog::AccessDialog(QDialog *parent, Qt::WindowFlags flags) : QDialog(parent, flags) diff --git a/src/appchooser.cpp b/src/appchooser.cpp --- a/src/appchooser.cpp +++ b/src/appchooser.cpp @@ -24,7 +24,7 @@ #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAppChooser, "xdg-desktop-portal-kde-app-chooser") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAppChooser, "xdp-kde-app-chooser") AppChooserPortal::AppChooserPortal(QObject *parent) diff --git a/src/appchooserdialog.cpp b/src/appchooserdialog.cpp --- a/src/appchooserdialog.cpp +++ b/src/appchooserdialog.cpp @@ -26,7 +26,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAppChooserDialog, "xdg-desktop-portal-kde-app-chooser-dialog") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeAppChooserDialog, "xdp-kde-app-chooser-dialog") AppChooserDialog::AppChooserDialog(const QStringList &choices, QDialog *parent, Qt::WindowFlags flags) : QDialog(parent, flags) diff --git a/src/desktopportal.h b/src/desktopportal.h --- a/src/desktopportal.h +++ b/src/desktopportal.h @@ -31,6 +31,7 @@ #include "inhibit.h" #include "notification.h" #include "print.h" +#include "screencast.h" class DesktopPortal : public QObject { @@ -47,6 +48,7 @@ InhibitPortal *m_inhibit; NotificationPortal *m_notification; PrintPortal *m_print; + ScreenCastPortal *m_screenCast; }; #endif // XDG_DESKTOP_PORTAL_KDE_DESKTOP_PORTAL_H diff --git a/src/desktopportal.cpp b/src/desktopportal.cpp --- a/src/desktopportal.cpp +++ b/src/desktopportal.cpp @@ -26,7 +26,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeDesktopPortal, "xdg-desktop-portal-kde-desktop-portal") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeDesktopPortal, "xdp-kde-desktop-portal") DesktopPortal::DesktopPortal(QObject *parent) : QObject(parent) @@ -37,6 +37,7 @@ , m_inhibit(new InhibitPortal(this)) , m_notification(new NotificationPortal(this)) , m_print(new PrintPortal(this)) + , m_screenCast(new ScreenCastPortal(this)) { } diff --git a/src/email.cpp b/src/email.cpp --- a/src/email.cpp +++ b/src/email.cpp @@ -24,7 +24,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeEmail, "xdg-desktop-portal-kde-email") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeEmail, "xdp-kde-email") EmailPortal::EmailPortal(QObject *parent) : QDBusAbstractAdaptor(parent) diff --git a/src/filechooser.cpp b/src/filechooser.cpp --- a/src/filechooser.cpp +++ b/src/filechooser.cpp @@ -26,7 +26,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeFileChooser, "xdg-desktop-portal-kde-file-chooser") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeFileChooser, "xdp-kde-file-chooser") // Keep in sync with qflatpakfiledialog from flatpak-platform-plugin Q_DECLARE_METATYPE(FileChooserPortal::Filter); diff --git a/src/inhibit.cpp b/src/inhibit.cpp --- a/src/inhibit.cpp +++ b/src/inhibit.cpp @@ -29,7 +29,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeInhibit, "xdg-desktop-portal-kde-inhibit") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeInhibit, "xdp-kde-inhibit") InhibitPortal::InhibitPortal(QObject *parent) : QDBusAbstractAdaptor(parent) diff --git a/src/notification.cpp b/src/notification.cpp --- a/src/notification.cpp +++ b/src/notification.cpp @@ -25,7 +25,7 @@ #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeNotification, "xdg-desktop-portal-kde-notification") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeNotification, "xdp-kde-notification") NotificationPortal::NotificationPortal(QObject *parent) : QDBusAbstractAdaptor(parent) diff --git a/src/print.cpp b/src/print.cpp --- a/src/print.cpp +++ b/src/print.cpp @@ -33,7 +33,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgDesktopPortalKdePrint, "xdg-desktop-portal-kde-print") +Q_LOGGING_CATEGORY(XdgDesktopPortalKdePrint, "xdp-kde-print") // INFO: code below is copied from Qt as there is no public API for converting key to PageSizeId diff --git a/src/request.cpp b/src/request.cpp --- a/src/request.cpp +++ b/src/request.cpp @@ -28,7 +28,7 @@ #include #include -Q_LOGGING_CATEGORY(XdgRequestKdeRequest, "xdg-desktop-portal-kde-request") +Q_LOGGING_CATEGORY(XdgRequestKdeRequest, "xdp-kde-request") Request::Request(QObject *parent, const QString &portalName, const QVariant &data) : QDBusVirtualObject(parent) diff --git a/src/screencast.h b/src/screencast.h new file mode 100644 --- /dev/null +++ b/src/screencast.h @@ -0,0 +1,156 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#ifndef XDG_DESKTOP_PORTAL_KDE_SCREENCAST_H +#define XDG_DESKTOP_PORTAL_KDE_SCREENCAST_H + +#include +#include +#include + +#include + +#include +#include + +namespace KWayland { + namespace Client { + class ConnectionThread; + class EventQueue; + class OutputDevice; + class Registry; + class RemoteAccessManager; + class RemoteBuffer; + class Output; + } +} + +class Session; +class ScreenChooserDialog; +class ScreenCastStream; + +class ScreenCastPortalOutput +{ + enum OutputType { + Laptop, + Monitor, + Television + }; + + void setOutputType(const QString &type); + + QString manufacturer; + QString model; + QSize resolution; + OutputType outputType; + + // Needed for later output binding + int waylandOutputName; + int waylandOutputVersion; + + friend class ScreenCastPortal; + friend class ScreenChooserDialog; +}; + +class ScreenCastPortal : public QDBusAbstractAdaptor +{ + Q_OBJECT + Q_CLASSINFO("D-Bus Interface", "org.freedesktop.impl.portal.ScreenCast") + Q_PROPERTY(uint version READ version) + Q_PROPERTY(uint AvailableSourceTypes READ AvailableSourceTypes) + +public: + typedef struct { + uint nodeId; + QVariantMap map; + } Stream; + typedef QList Streams; + + enum SourceType { + Any = 0, + Monitor, + Window + }; + + ScreenCastPortal(QObject *parent); + ~ScreenCastPortal(); + + uint version() const { return 1; } + uint AvailableSourceTypes() const { return Monitor; }; + +public Q_SLOTS: + uint CreateSession(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QVariantMap &options, + QVariantMap &results); + + uint SelectSources(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QVariantMap &options, + QVariantMap &results); + + uint Start(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QString &parent_window, + const QVariantMap &options, + QVariantMap &results); + +private Q_SLOTS: + void addOutput(quint32 name, quint32 version); + void removeOutput(quint32 name); + void processBuffer(const KWayland::Client::RemoteBuffer *rbuf); + void setupRegistry(); + +private: + void initDrm(); + void initEGL(); + void initPipewire(); + void initWayland(); + + bool m_registryInitialized; + bool m_streamingEnabled; + + QMap m_sessionList; + QMap m_outputMap; + QList m_bindOutputs; + + QThread *m_thread; + + ScreenCastStream *m_stream; + + KWayland::Client::ConnectionThread *m_connection; + KWayland::Client::EventQueue *m_queue; + KWayland::Client::Registry *m_registry; + KWayland::Client::RemoteAccessManager *m_remoteAccessManager; + + qint32 m_drmFd = 0; // for GBM buffer mmap + gbm_device *m_gbmDevice = nullptr; // for passed GBM buffer retrieval + struct { + QList extensions; + EGLDisplay display = EGL_NO_DISPLAY; + EGLContext context = EGL_NO_CONTEXT; + } m_egl; +}; + +#endif // XDG_DESKTOP_PORTAL_KDE_SCREENCAST_H + diff --git a/src/screencast.cpp b/src/screencast.cpp new file mode 100644 --- /dev/null +++ b/src/screencast.cpp @@ -0,0 +1,573 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#include "screencast.h" +#include "session.h" +#include "screencaststream.h" +#include "screenchooserdialog.h" + +#include +#include +#include +#include + +#include +#include +#include + +// KWayland +#include +#include +#include +#include +#include + +// system +#include +#include + +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeScreenCast, "xdp-kde-screencast") + +Q_DECLARE_METATYPE(ScreenCastPortal::Stream); +Q_DECLARE_METATYPE(ScreenCastPortal::Streams); + +const QDBusArgument &operator >> (const QDBusArgument &arg, ScreenCastPortal::Stream &stream) +{ + arg.beginStructure(); + arg >> stream.nodeId; + + arg.beginMap(); + while (!arg.atEnd()) { + QString key; + QVariant map; + arg.beginMapEntry(); + arg >> key >> map; + arg.endMapEntry(); + stream.map.insert(key, map); + } + arg.endMap(); + arg.endStructure(); + + return arg; +} + +const QDBusArgument &operator << (QDBusArgument &arg, const ScreenCastPortal::Stream &stream) +{ + arg.beginStructure(); + arg << stream.nodeId; + arg << stream.map; + arg.endStructure(); + + return arg; +} + +static const char * formatGLError(GLenum err) +{ + switch(err) { + case GL_NO_ERROR: + return "GL_NO_ERROR"; + case GL_INVALID_ENUM: + return "GL_INVALID_ENUM"; + case GL_INVALID_VALUE: + return "GL_INVALID_VALUE"; + case GL_INVALID_OPERATION: + return "GL_INVALID_OPERATION"; + case GL_STACK_OVERFLOW: + return "GL_STACK_OVERFLOW"; + case GL_STACK_UNDERFLOW: + return "GL_STACK_UNDERFLOW"; + case GL_OUT_OF_MEMORY: + return "GL_OUT_OF_MEMORY"; + default: + return (QLatin1String("0x") + QString::number(err, 16)).toLocal8Bit().constData(); + } +} + +// Thank you kscreen +void ScreenCastPortalOutput::setOutputType(const QString &type) +{ + const auto embedded = { QLatin1String("LVDS"), + QLatin1String("IDP"), + QLatin1String("EDP"), + QLatin1String("LCD") }; + + for (const QLatin1String &pre : embedded) { + if (type.toUpper().startsWith(pre)) { + outputType = OutputType::Laptop; + return; + } + } + + if (type.contains("VGA") || type.contains("DVI") || type.contains("HDMI") || type.contains("Panel") || + type.contains("DisplayPort") || type.startsWith("DP") || type.contains("unknown")) { + outputType = OutputType::Monitor; + } else if (type.contains("TV")) { + outputType = OutputType::Television; + } else { + outputType = OutputType::Monitor; + } +} + +ScreenCastPortal::ScreenCastPortal(QObject *parent) + : QDBusAbstractAdaptor(parent) + , m_registryInitialized(false) + , m_streamingEnabled(false) + , m_connection(nullptr) + , m_queue(nullptr) + , m_registry(nullptr) + , m_remoteAccessManager(nullptr) +{ + initDrm(); + initEGL(); + initPipewire(); + initWayland(); + + qDBusRegisterMetaType(); + qDBusRegisterMetaType(); +} + +ScreenCastPortal::~ScreenCastPortal() +{ + if (m_remoteAccessManager) { + m_remoteAccessManager->destroy(); + } + + if (m_drmFd) { + gbm_device_destroy(m_gbmDevice); + } + + m_stream->deleteLater(); +} + +void ScreenCastPortal::initDrm() +{ + m_drmFd = open("/dev/dri/renderD128", O_RDWR); + m_gbmDevice = gbm_create_device(m_drmFd); + + if (!m_gbmDevice) { + qFatal("Cannot create GBM device: %s", strerror(errno)); + } +} + +void ScreenCastPortal::initEGL() +{ + // Get the list of client extensions + const char* clientExtensionsCString = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); + const QByteArray clientExtensionsString = QByteArray::fromRawData(clientExtensionsCString, qstrlen(clientExtensionsCString)); + if (clientExtensionsString.isEmpty()) { + // If eglQueryString() returned NULL, the implementation doesn't support + // EGL_EXT_client_extensions. Expect an EGL_BAD_DISPLAY error. + qFatal("No client extensions defined! %s", formatGLError(eglGetError())); + } + + m_egl.extensions = clientExtensionsString.split(' '); + + // Use eglGetPlatformDisplayEXT() to get the display pointer + // if the implementation supports it. + if (!m_egl.extensions.contains(QByteArrayLiteral("EGL_EXT_platform_base")) || + !m_egl.extensions.contains(QByteArrayLiteral("EGL_MESA_platform_gbm"))) { + qFatal("One of required EGL extensions is missing"); + } + + m_egl.display = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, m_gbmDevice, nullptr); + + if (m_egl.display == EGL_NO_DISPLAY) { + qFatal("Error during obtaining EGL display: %s", formatGLError(eglGetError())); + } + + EGLint major, minor; + if (eglInitialize(m_egl.display, &major, &minor) == EGL_FALSE) { + qFatal("Error during eglInitialize: %s", formatGLError(eglGetError())); + } + + if (eglBindAPI(EGL_OPENGL_API) == EGL_FALSE) { + qFatal("bind OpenGL API failed"); + } + + m_egl.context = eglCreateContext(m_egl.display, nullptr, EGL_NO_CONTEXT, nullptr); + + if (m_egl.context == EGL_NO_CONTEXT) { + qFatal("Couldn't create EGL context: %s", formatGLError(eglGetError())); + } + + qCDebug(XdgDesktopPortalKdeScreenCast) << "Egl initialization succeeded"; + qCDebug(XdgDesktopPortalKdeScreenCast) << QString("EGL version: %1.%2").arg(major).arg(minor); +} + +void ScreenCastPortal::initPipewire() +{ + m_stream = new ScreenCastStream; + m_stream->init(); + + connect(m_stream, &ScreenCastStream::streamReady, this, [] (uint nodeId) { + qCDebug(XdgDesktopPortalKdeScreenCast) << "Pipewire stream is ready: " << nodeId; + }); + + connect(m_stream, &ScreenCastStream::startStreaming, this, [this] { + qCDebug(XdgDesktopPortalKdeScreenCast) << "Start streaming"; + m_streamingEnabled = true; + + if (!m_registryInitialized) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Cannot start stream because registry is not initialized yet"; + return; + } + if (m_registry->hasInterface(KWayland::Client::Registry::Interface::RemoteAccessManager)) { + KWayland::Client::Registry::AnnouncedInterface interface = m_registry->interface(KWayland::Client::Registry::Interface::RemoteAccessManager); + if (!interface.name && !interface.version) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Cannot start stream because remote access interface is not initialized yet"; + return; + } + m_remoteAccessManager = m_registry->createRemoteAccessManager(interface.name, interface.version); + connect(m_remoteAccessManager, &KWayland::Client::RemoteAccessManager::bufferReady, this, [this] (const void *output, const KWayland::Client::RemoteBuffer * rbuf) { + Q_UNUSED(output); + connect(rbuf, &KWayland::Client::RemoteBuffer::parametersObtained, this, [this, rbuf] { + processBuffer(rbuf); + }); + }); + } + }); + + connect(m_stream, &ScreenCastStream::stopStreaming, this, [this] { + if (m_streamingEnabled) { + qCDebug(XdgDesktopPortalKdeScreenCast) << "Stop streaming"; + m_remoteAccessManager->release(); + m_remoteAccessManager->destroy(); + + m_streamingEnabled = false; + m_stream->removeStream(); + + qDeleteAll(m_bindOutputs); + m_bindOutputs.clear(); + } + }); +} + +void ScreenCastPortal::initWayland() +{ + m_thread = new QThread(this); + m_connection = new KWayland::Client::ConnectionThread; + + connect(m_connection, &KWayland::Client::ConnectionThread::connected, this, &ScreenCastPortal::setupRegistry, Qt::QueuedConnection); + connect(m_connection, &KWayland::Client::ConnectionThread::connectionDied, this, [this] { + if (m_queue) { + delete m_queue; + m_queue = nullptr; + } + + m_connection->deleteLater(); + m_connection = nullptr; + + if (m_thread) { + m_thread->quit(); + if (!m_thread->wait(3000)) { + m_thread->terminate(); + m_thread->wait(); + } + delete m_thread; + m_thread = nullptr; + } + }); + connect(m_connection, &KWayland::Client::ConnectionThread::failed, this, [this] { + m_thread->quit(); + m_thread->wait(); + }); + + m_thread->start(); + m_connection->moveToThread(m_thread); + m_connection->initConnection(); +} + +uint ScreenCastPortal::CreateSession(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QVariantMap &options, + QVariantMap &results) +{ + Q_UNUSED(results) + + qCDebug(XdgDesktopPortalKdeScreenCast) << "CreateSession called with parameters:"; + qCDebug(XdgDesktopPortalKdeScreenCast) << " handle: " << handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " session_handle: " << session_handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " app_id: " << app_id; + qCDebug(XdgDesktopPortalKdeScreenCast) << " options: " << options; + + QDBusConnection sessionBus = QDBusConnection::sessionBus(); + Session *session = new Session(this, app_id, session_handle.path()); + if (sessionBus.registerVirtualObject(session_handle.path(), session, QDBusConnection::VirtualObjectRegisterOption::SubPath)) { + connect(session, &Session::closed, [this, session, session_handle] () { + m_sessionList.remove(session_handle.path()); + QDBusConnection::sessionBus().unregisterObject(session_handle.path()); + session->deleteLater(); + }); + m_sessionList.insert(session_handle.path(), session); + return 0; + } else { + qCDebug(XdgDesktopPortalKdeScreenCast) << sessionBus.lastError().message(); + qCDebug(XdgDesktopPortalKdeScreenCast) << "Failed to register session object: " << session_handle.path(); + session->deleteLater(); + return 2; + } +} + +uint ScreenCastPortal::SelectSources(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QVariantMap &options, + QVariantMap &results) +{ + Q_UNUSED(results) + + qCDebug(XdgDesktopPortalKdeScreenCast) << "SelectSource called with parameters:"; + qCDebug(XdgDesktopPortalKdeScreenCast) << " handle: " << handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " session_handle: " << session_handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " app_id: " << app_id; + qCDebug(XdgDesktopPortalKdeScreenCast) << " options: " << options; + + uint types = Monitor; + Session *session = nullptr; + + session = m_sessionList.value(session_handle.path()); + + if (!session) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Tried to select sources on non-existing session " << session_handle.path(); + return 2; + } + + if (options.contains(QLatin1String("multiple"))) { + session->setMultipleSources(options.value(QLatin1String("multiple")).toBool()); + } + + if (options.contains(QLatin1String("types"))) { + types = (SourceType)(options.value(QLatin1String("types")).toUInt()); + } + + if (types == Window) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Screen cast of a window is not implemented"; + return 2; + } + + return 0; +} + +uint ScreenCastPortal::Start(const QDBusObjectPath &handle, + const QDBusObjectPath &session_handle, + const QString &app_id, + const QString &parent_window, + const QVariantMap &options, + QVariantMap &results) +{ + Q_UNUSED(results) + + qCDebug(XdgDesktopPortalKdeScreenCast) << "Start called with parameters:"; + qCDebug(XdgDesktopPortalKdeScreenCast) << " handle: " << handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " session_handle: " << session_handle.path(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " app_id: " << app_id; + qCDebug(XdgDesktopPortalKdeScreenCast) << " parent_window: " << parent_window; + qCDebug(XdgDesktopPortalKdeScreenCast) << " options: " << options; + + Session *session = nullptr; + session = m_sessionList.value(session_handle.path()); + + if (!session) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Tried to select sources on non-existing session " << session_handle.path(); + return 2; + } + + // TODO check whether we got some outputs? + if (m_outputMap.isEmpty()) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Failed to show dialog as there is no screen to select"; + return 2; + } + + QScopedPointer screenDialog(new ScreenChooserDialog(m_outputMap, session->multipleSources())); + + if (screenDialog->exec()) { + ScreenCastPortalOutput selectedOutput = m_outputMap.value(screenDialog->selectedScreens().first()); + + // HACK wait for stream to be ready + bool streamReady = false; + QEventLoop loop; + connect(m_stream, &ScreenCastStream::streamReady, this, [&loop, &streamReady] { + loop.quit(); + streamReady = true; + }); + + if (!m_stream->createStream(selectedOutput.resolution)) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Failed to create pipewire stream"; + return 2; + } + + QTimer::singleShot(3000, &loop, &QEventLoop::quit); + loop.exec(); + + if (!streamReady) { + qCWarning(XdgDesktopPortalKdeScreenCast) << "Pipewire stream is not ready to be streamed"; + return 2; + } + + // TODO support multiple outputs + + qCDebug(XdgDesktopPortalKdeScreenCast) << "Pipewire node id: " << m_stream->nodeId(); + + KWayland::Client::Output *output = new KWayland::Client::Output(this); + output->setup(m_registry->bindOutput(selectedOutput.waylandOutputName, selectedOutput.waylandOutputVersion)); + m_bindOutputs << output; + + Stream stream; + stream.nodeId = m_stream->nodeId(); + stream.map = QVariantMap({{QLatin1String("size"), selectedOutput.resolution}}); + results.insert(QLatin1String("streams"), QVariant::fromValue({stream})); + + return 0; + } + + return 0; +} + +void ScreenCastPortal::addOutput(quint32 name, quint32 version) +{ + KWayland::Client::Output *output = new KWayland::Client::Output(this); + output->setup(m_registry->bindOutput(name, version)); + + connect(output, &KWayland::Client::Output::changed, this, [this, name, version, output] () { + qCDebug(XdgDesktopPortalKdeScreenCast) << "Adding output:"; + qCDebug(XdgDesktopPortalKdeScreenCast) << " manufacturer: " << output->manufacturer(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " model: " << output->model(); + qCDebug(XdgDesktopPortalKdeScreenCast) << " resolution: " << output->pixelSize(); + + ScreenCastPortalOutput portalOutput; + portalOutput.manufacturer = output->manufacturer(); + portalOutput.model = output->model(); + portalOutput.resolution = output->pixelSize(); + portalOutput.waylandOutputName = name; + portalOutput.waylandOutputVersion = version; + portalOutput.setOutputType(output->model()); + + m_outputMap.insert(name, portalOutput); + + delete output; + }); +} + +void ScreenCastPortal::removeOutput(quint32 name) +{ + ScreenCastPortalOutput output = m_outputMap.take(name); + qCDebug(XdgDesktopPortalKdeScreenCast) << "Removing output:"; + qCDebug(XdgDesktopPortalKdeScreenCast) << " manufacturer: " << output.manufacturer; + qCDebug(XdgDesktopPortalKdeScreenCast) << " model: " << output.model; +} + +void ScreenCastPortal::processBuffer(const KWayland::Client::RemoteBuffer* rbuf) +{ + QScopedPointer guard(rbuf); + + auto gbmHandle = rbuf->fd(); + auto width = rbuf->width(); + auto height = rbuf->height(); + auto stride = rbuf->stride(); + auto format = rbuf->format(); + + qCDebug(XdgDesktopPortalKdeScreenCast) << QString("Incoming GBM fd %1, %2x%3, stride %4, fourcc 0x%5").arg(gbmHandle).arg(width).arg(height).arg(stride).arg(QString::number(format, 16)); + + if (!m_streamingEnabled) { + qCDebug(XdgDesktopPortalKdeScreenCast) << "Streaming is disabled"; + close(gbmHandle); + return; + } + + if (!gbm_device_is_format_supported(m_gbmDevice, format, GBM_BO_USE_SCANOUT)) { + qCritical() << "GBM format is not supported by device!"; + } + + // import GBM buffer that was passed from KWin + gbm_import_fd_data importInfo = {gbmHandle, width, height, stride, format}; + gbm_bo *imported = gbm_bo_import(m_gbmDevice, GBM_BO_IMPORT_FD, &importInfo, GBM_BO_USE_SCANOUT); + if (!imported) { + qCritical() << "Cannot import passed GBM fd:" << strerror(errno); + } + + // bind context to render thread + eglMakeCurrent(m_egl.display, EGL_NO_SURFACE, EGL_NO_SURFACE, m_egl.context); + + // create EGL image from imported BO + EGLImageKHR image = eglCreateImageKHR(m_egl.display, NULL, EGL_NATIVE_PIXMAP_KHR, imported, NULL); + if (image == EGL_NO_IMAGE_KHR) { + qCritical() << "Error creating EGLImageKHR" << formatGLError(glGetError()); + return; + } + // create GL 2D texture for framebuffer + GLuint texture; + glGenTextures(1, &texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glBindTexture(GL_TEXTURE_2D, texture); + glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); + + // bind framebuffer to copy pixels from + GLuint framebuffer; + glGenFramebuffers(1, &framebuffer); + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); + const GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (status != GL_FRAMEBUFFER_COMPLETE) { + qCritical() << "glCheckFramebufferStatus failed:" << formatGLError(glGetError()); + glDeleteTextures(1, &texture); + glDeleteFramebuffers(1, &framebuffer); + eglDestroyImageKHR(m_egl.display, image); + return; + } + + auto capture = new QImage(QSize(width, height), QImage::Format_RGBA8888); + glViewport(0, 0, width, height); + glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, capture->bits()); + + m_stream->recordFrame(capture->bits()); + + gbm_bo_destroy(imported); + glDeleteTextures(1, &texture); + glDeleteFramebuffers(1, &framebuffer); + eglDestroyImageKHR(m_egl.display, image); + + delete capture; + + close(gbmHandle); +} + +void ScreenCastPortal::setupRegistry() +{ + m_queue = new KWayland::Client::EventQueue(this); + m_queue->setup(m_connection); + + m_registry = new KWayland::Client::Registry(this); + + connect(m_registry, &KWayland::Client::Registry::outputAnnounced, this, &ScreenCastPortal::addOutput); + connect(m_registry, &KWayland::Client::Registry::outputRemoved, this, &ScreenCastPortal::removeOutput); + + connect(m_registry, &KWayland::Client::Registry::interfacesAnnounced, this, [this] { + m_registryInitialized = true; + qCDebug(XdgDesktopPortalKdeScreenCast) << "Registry initialized"; + }); + + m_registry->create(m_connection); + m_registry->setEventQueue(m_queue); + m_registry->setup(); +} diff --git a/src/screencaststream.h b/src/screencaststream.h new file mode 100644 --- /dev/null +++ b/src/screencaststream.h @@ -0,0 +1,99 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#ifndef SCREEN_CAST_STREAM_H +#define SCREEN_CAST_STREAM_H + +#include +#include + +#include + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +class PwType { +public: + spa_type_media_type media_type; + spa_type_media_subtype media_subtype; + spa_type_format_video format_video; + spa_type_video_format video_format; +}; + +class QSocketNotifier; + +class ScreenCastStream : public QObject +{ + Q_OBJECT +public: + explicit ScreenCastStream(QObject *parent = nullptr); + ~ScreenCastStream(); + + // Public + void init(); + uint nodeId(); + + // Public because we need access from static functions + bool createStream(const QSize &resolution); + bool recordFrame(uint8_t *screenData); + + void removeStream(); +Q_SIGNALS: + void streamReady(uint nodeId); + void startStreaming(); + void stopStreaming(); + +private: + void initializePwTypes(); + +private Q_SLOTS: + void processPipewireEvents(); + +public: + pw_core *pwCore = nullptr; + pw_loop *pwLoop = nullptr; + pw_node *pwNode = nullptr; + pw_stream *pwStream = nullptr; + pw_type *pwCoreType = nullptr; + pw_remote *pwRemote = nullptr; + PwType *pwType = nullptr; + + spa_hook remoteListener; + spa_hook streamListener; + + QScopedPointer socketNotifier; + + spa_video_info_raw videoFormat; + +}; + +#endif // SCREEN_CAST_STREAM_H + + diff --git a/src/screencaststream.cpp b/src/screencaststream.cpp new file mode 100644 --- /dev/null +++ b/src/screencaststream.cpp @@ -0,0 +1,419 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#include "screencaststream.h" + +#include +#include +#include + +#include +#include +#include +#include + +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeScreenCastStream, "xdp-kde-screencast-stream") + +class PwFraction { +public: + int num; + int denom; +}; + +// Stolen from mutter + +#define MAX_TERMS 30 +#define MIN_DIVISOR 1.0e-10 +#define MAX_ERROR 1.0e-20 + +#define PROP_RANGE(min, max) 2, (min), (max) + +#define BITS_PER_PIXEL 4 + +static int greatestCommonDivisor(int a, int b) +{ + while (b != 0) { + int temp = a; + + a = b; + b = temp % b; + } + + return ABS(a); +} + +static PwFraction pipewireFractionFromDouble(double src) +{ + double V, F; /* double being converted */ + int N, D; /* will contain the result */ + int A; /* current term in continued fraction */ + int64_t N1, D1; /* numerator, denominator of last approx */ + int64_t N2, D2; /* numerator, denominator of previous approx */ + int i; + int gcd; + gboolean negative = FALSE; + + /* initialize fraction being converted */ + F = src; + if (F < 0.0) { + F = -F; + negative = TRUE; + } + + V = F; + /* initialize fractions with 1/0, 0/1 */ + N1 = 1; + D1 = 0; + N2 = 0; + D2 = 1; + N = 1; + D = 1; + + for (i = 0; i < MAX_TERMS; i++) { + /* get next term */ + A = (gint) F; /* no floor() needed, F is always >= 0 */ + /* get new divisor */ + F = F - A; + + /* calculate new fraction in temp */ + N2 = N1 * A + N2; + D2 = D1 * A + D2; + + /* guard against overflow */ + if (N2 > G_MAXINT || D2 > G_MAXINT) + break; + + N = N2; + D = D2; + + /* save last two fractions */ + N2 = N1; + D2 = D1; + N1 = N; + D1 = D; + + /* quit if dividing by zero or close enough to target */ + if (F < MIN_DIVISOR || fabs (V - ((gdouble) N) / D) < MAX_ERROR) + break; + + /* Take reciprocal */ + F = 1 / F; + } + + /* fix for overflow */ + if (D == 0) { + N = G_MAXINT; + D = 1; + } + + /* fix for negative */ + if (negative) + N = -N; + + /* simplify */ + gcd = greatestCommonDivisor(N, D); + if (gcd) { + N /= gcd; + D /= gcd; + } + + PwFraction fraction; + fraction.num = N; + fraction.denom = D; + + return fraction; +} + +static void onStateChanged(void *_data, pw_remote_state old, pw_remote_state state, const char *error) +{ + Q_UNUSED(old); + Q_UNUSED(_data); + + switch (state) { + case PW_REMOTE_STATE_ERROR: + // TODO notify error + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Remote error: " << error; + break; + case PW_REMOTE_STATE_CONNECTED: + // TODO notify error + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Remote state: " << pw_remote_state_as_string(state); + break; + default: + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Remote state: " << pw_remote_state_as_string(state); + break; + } +} + +static void onStreamStateChanged(void *data, pw_stream_state old, pw_stream_state state, const char *error_message) +{ + Q_UNUSED(old) + + ScreenCastStream *pw = static_cast(data); + + switch (state) { + case PW_STREAM_STATE_ERROR: + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Stream error: " << error_message; + break; + case PW_STREAM_STATE_CONFIGURE: + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state); + Q_EMIT pw->streamReady((uint)pw_stream_get_node_id(pw->pwStream)); + break; + case PW_STREAM_STATE_UNCONNECTED: + case PW_STREAM_STATE_CONNECTING: + case PW_STREAM_STATE_READY: + case PW_STREAM_STATE_PAUSED: + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state); + Q_EMIT pw->stopStreaming(); + break; + case PW_STREAM_STATE_STREAMING: + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state); + Q_EMIT pw->startStreaming(); + break; + } +} + +static void onStreamFormatChanged(void *data, struct spa_pod *format) +{ + qCDebug(XdgDesktopPortalKdeScreenCastStream) << "Stream format changed"; + + ScreenCastStream *pw = static_cast(data); + + uint8_t paramsBuffer[1024]; + int32_t width, height, stride, size; + struct spa_pod_builder pod_builder; + struct spa_pod *params[1]; + const int bpp = 4; + + if (!format) { + pw_stream_finish_format(pw->pwStream, 0, NULL, 0); + return; + } + + spa_format_video_raw_parse (format, &pw->videoFormat, &pw->pwType->format_video); + + width = pw->videoFormat.size.width; + height =pw->videoFormat.size.height; + stride = SPA_ROUND_UP_N (width * bpp, 4); + size = height * stride; + + pod_builder = SPA_POD_BUILDER_INIT (paramsBuffer, sizeof (paramsBuffer)); + + params[0] = (spa_pod*) spa_pod_builder_object (&pod_builder, + pw->pwCoreType->param.idBuffers, pw->pwCoreType->param_buffers.Buffers, + ":", pw->pwCoreType->param_buffers.size, "i", size, + ":", pw->pwCoreType->param_buffers.stride, "i", stride, + ":", pw->pwCoreType->param_buffers.buffers, "iru", 16, PROP_RANGE (2, 16), + ":", pw->pwCoreType->param_buffers.align, "i", 16); + + pw_stream_finish_format (pw->pwStream, 0, + params, G_N_ELEMENTS (params)); +} + +static const struct pw_remote_events pwRemoteEvents = { + .version = PW_VERSION_REMOTE_EVENTS, + .destroy = nullptr, + .info_changed = nullptr, + .sync_reply = nullptr, + .state_changed = onStateChanged, +}; + +static const struct pw_stream_events pwStreamEvents = { + .version = PW_VERSION_STREAM_EVENTS, + .destroy = nullptr, + .state_changed = onStreamStateChanged, + .format_changed = onStreamFormatChanged, + .add_buffer = nullptr, + .remove_buffer = nullptr, + .new_buffer = nullptr, + .need_buffer = nullptr, +}; + +ScreenCastStream::ScreenCastStream(QObject *parent) + : QObject(parent) +{ +} + +ScreenCastStream::~ScreenCastStream() +{ + if (pwType) { + delete pwType; + } + + if (pwCore) { + pw_core_destroy(pwCore); + } + + if (pwLoop) { + pw_loop_leave(pwLoop); + pw_loop_destroy(pwLoop); + } +} + +void ScreenCastStream::init() +{ + pw_init(nullptr, nullptr); + + pwLoop = pw_loop_new(nullptr); + socketNotifier.reset(new QSocketNotifier(pw_loop_get_fd(pwLoop), QSocketNotifier::Read)); + connect(socketNotifier.data(), &QSocketNotifier::activated, this, &ScreenCastStream::processPipewireEvents); + + pwCore = pw_core_new(pwLoop, nullptr); + pwCoreType = pw_core_get_type(pwCore); + pwRemote = pw_remote_new(pwCore, nullptr, 0); + + spa_debug_set_type_map(pwCoreType->map); + + initializePwTypes(); + + pw_remote_add_listener(pwRemote, &remoteListener, &pwRemoteEvents, this); + + pw_remote_connect(pwRemote); +} + +uint ScreenCastStream::nodeId() +{ + if (pwStream) { + return (uint)pw_stream_get_node_id(pwStream); + } + + return 0; +} + +bool ScreenCastStream::createStream(const QSize &resolution) +{ + if (pw_remote_get_state(pwRemote, nullptr) != PW_REMOTE_STATE_CONNECTED) { + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Cannot create pipewire stream"; + return false; + } + + uint8_t buffer[1024]; + spa_pod_builder podBuilder = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer)); + + const float frameRate = 25; + + spa_fraction maxFramerate; + spa_fraction minFramerate; + const spa_pod *params[1]; + + pwStream = pw_stream_new(pwRemote, "kwin-screen-cast", nullptr); + + PwFraction fraction = pipewireFractionFromDouble(frameRate); + + minFramerate = SPA_FRACTION(1, 1); + maxFramerate = SPA_FRACTION((uint32_t)fraction.num, (uint32_t)fraction.denom); + + spa_fraction paramFraction = SPA_FRACTION(0, 1); + spa_rectangle paramRectangle = SPA_RECTANGLE((uint32_t)resolution.width(), (uint32_t)resolution.height()); + + params[0] = (spa_pod*)spa_pod_builder_object(&podBuilder, + pwCoreType->param.idEnumFormat, pwCoreType->spa_format, + "I", pwType->media_type.video, + "I", pwType->media_subtype.raw, + ":", pwType->format_video.format, "I", pwType->video_format.RGBx, + ":", pwType->format_video.size, "R", ¶mRectangle, + ":", pwType->format_video.framerate, "F", ¶mFraction, + ":", pwType->format_video.max_framerate, "Fr", &maxFramerate, PROP_RANGE (&minFramerate, &maxFramerate)); + + pw_stream_add_listener(pwStream, &streamListener, &pwStreamEvents, this); + + if (pw_stream_connect(pwStream, PW_DIRECTION_OUTPUT, nullptr, PW_STREAM_FLAG_NONE, params, G_N_ELEMENTS(¶ms)) != 0) { + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Could not connect to stream"; + return false; + } + + return true; +} + +bool ScreenCastStream::recordFrame(uint8_t *screenData) +{ + uint32_t bufferId; + struct spa_buffer *buffer; + uint8_t *map = nullptr; + uint8_t *data = nullptr; + + // TODO check timestamp like mutter does? + + if (!pwStream) { + return false; + } + + bufferId = pw_stream_get_empty_buffer(pwStream); + + if (bufferId == SPA_ID_INVALID) { + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Failed to get empty stream buffer: " << strerror(errno); + return false; + } + + buffer = pw_stream_peek_buffer(pwStream, bufferId); + + if (buffer->datas[0].type == pwCoreType->data.MemFd) { + map = (uint8_t *)mmap(nullptr, buffer->datas[0].maxsize + buffer->datas[0].mapoffset, PROT_READ | PROT_WRITE, MAP_SHARED, buffer->datas[0].fd, 0); + + if (map == MAP_FAILED) { + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Failed to mmap pipewire stream buffer: " << strerror(errno); + return false; + } + + data = SPA_MEMBER(map, buffer->datas[0].mapoffset, uint8_t); + } else if (buffer->datas[0].type == pwCoreType->data.MemPtr) { + data = (uint8_t *) buffer->datas[0].data; + } else { + return false; + } + + memcpy(data, screenData, BITS_PER_PIXEL * videoFormat.size.height * videoFormat.size.width * sizeof(uint8_t)); + + if (map) { + munmap(map, buffer->datas[0].maxsize + buffer->datas[0].mapoffset); + } + + buffer->datas[0].chunk->size = buffer->datas[0].maxsize; + + pw_stream_send_buffer(pwStream, bufferId); + + return true; +} + +void ScreenCastStream::removeStream() +{ + pw_stream_destroy(pwStream); + pwStream = nullptr; +} + +void ScreenCastStream::initializePwTypes() +{ + // raw C-like ScreenCastStream type map + auto map = pwCoreType->map; + + pwType = new PwType(); + + spa_type_media_type_map(map, &pwType->media_type); + spa_type_media_subtype_map(map, &pwType->media_subtype); + spa_type_format_video_map (map, &pwType->format_video); + spa_type_video_format_map (map, &pwType->video_format); +} + +void ScreenCastStream::processPipewireEvents() +{ + int result = pw_loop_iterate(pwLoop, 0); + if (result < 0) { + qCWarning(XdgDesktopPortalKdeScreenCastStream) << "Failed to iterate over pipewire loop: " << spa_strerror(result); + } +} diff --git a/src/desktopportal.cpp b/src/screenchooserdialog.h copy from src/desktopportal.cpp copy to src/screenchooserdialog.h --- a/src/desktopportal.cpp +++ b/src/screenchooserdialog.h @@ -1,5 +1,5 @@ /* - * Copyright © 2016 Red Hat, Inc + * Copyright © 2018 Red Hat, Inc * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,28 +18,30 @@ * Jan Grulich */ -#include "desktopportal.h" +#ifndef XDG_DESKTOP_PORTAL_KDE_SCREENCHOOSER_DIALOG_H +#define XDG_DESKTOP_PORTAL_KDE_SCREENCHOOSER_DIALOG_H +#include #include -#include -#include -#include -#include - -Q_LOGGING_CATEGORY(XdgDesktopPortalKdeDesktopPortal, "xdg-desktop-portal-kde-desktop-portal") - -DesktopPortal::DesktopPortal(QObject *parent) - : QObject(parent) - , m_access(new AccessPortal(this)) - , m_appChooser(new AppChooserPortal(this)) - , m_email(new EmailPortal(this)) - , m_fileChooser(new FileChooserPortal(this)) - , m_inhibit(new InhibitPortal(this)) - , m_notification(new NotificationPortal(this)) - , m_print(new PrintPortal(this)) + +namespace Ui { +class ScreenChooserDialog; } -DesktopPortal::~DesktopPortal() +class ScreenCastPortalOutput; + +class ScreenChooserDialog : public QDialog { -} + Q_OBJECT +public: + ScreenChooserDialog(const QMap &screens, bool multiple = false, QDialog *parent = nullptr, Qt::WindowFlags flags = 0); + ~ScreenChooserDialog(); + + QList selectedScreens() const; + +private: + Ui::ScreenChooserDialog * m_dialog; +}; + +#endif // XDG_DESKTOP_PORTAL_KDE_SCREENCHOOSER_DIALOG_H diff --git a/src/screenchooserdialog.cpp b/src/screenchooserdialog.cpp new file mode 100644 --- /dev/null +++ b/src/screenchooserdialog.cpp @@ -0,0 +1,83 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#include "screenchooserdialog.h" +#include "ui_screenchooserdialog.h" +#include "screencast.h" + +#include +#include +#include +#include + +Q_LOGGING_CATEGORY(XdgDesktopPortalKdeScreenChooserDialog, "xdp-kde-screen-chooser-dialog") + +ScreenChooserDialog::ScreenChooserDialog(const QMap &screens, bool multiple, QDialog *parent, Qt::WindowFlags flags) + : QDialog(parent, flags) + , m_dialog(new Ui::ScreenChooserDialog) +{ + m_dialog->setupUi(this); + + QMapIterator it(screens); + while (it.hasNext()) { + it.next(); + QListWidgetItem *widgetItem = new QListWidgetItem(m_dialog->screenView); + widgetItem->setData(Qt::UserRole, it.key()); + if (it.value().outputType == ScreenCastPortalOutput::Laptop) { + widgetItem->setIcon(QIcon::fromTheme("computer-laptop")); + widgetItem->setText(i18n("Laptop screen\nModel: %1").arg(it.value().model)); + } else if (it.value().outputType == ScreenCastPortalOutput::Monitor) { + widgetItem->setIcon(QIcon::fromTheme("video-display")); + widgetItem->setText(i18n("Manufacturer: %1\nModel: %2").arg(it.value().manufacturer).arg(it.value().model)); + } else { + widgetItem->setIcon(QIcon::fromTheme("video-television")); + widgetItem->setText(i18n("Manufacturer: %1\nModel: %2").arg(it.value().manufacturer).arg(it.value().model)); + } + } + + m_dialog->screenView->setItemSelected(m_dialog->screenView->itemAt(0, 0), true); + + connect(m_dialog->buttonBox, &QDialogButtonBox::accepted, this, &ScreenChooserDialog::accept); + connect(m_dialog->buttonBox, &QDialogButtonBox::rejected, this, &ScreenChooserDialog::reject); + connect(m_dialog->screenView, &QListWidget::itemDoubleClicked, this, &ScreenChooserDialog::accept); + + if (multiple) { + m_dialog->screenView->setSelectionMode(QAbstractItemView::ExtendedSelection); + } + + m_dialog->buttonBox->button(QDialogButtonBox::Ok)->setText(i18n("Share")); + setWindowTitle(i18n("Select screen to share")); +} + +ScreenChooserDialog::~ScreenChooserDialog() +{ + delete m_dialog; +} + +QList ScreenChooserDialog::selectedScreens() const +{ + QList selectedScreens; + + foreach (QListWidgetItem *item, m_dialog->screenView->selectedItems()) { + selectedScreens << item->data(Qt::UserRole).toUInt(); + } + + return selectedScreens; +} diff --git a/src/screenchooserdialog.ui b/src/screenchooserdialog.ui new file mode 100644 --- /dev/null +++ b/src/screenchooserdialog.ui @@ -0,0 +1,47 @@ + + + ScreenChooserDialog + + + + 0 + 0 + 400 + 300 + + + + Dialog + + + + + + + + + QAbstractItemView::SingleSelection + + + + 48 + 48 + + + + false + + + + + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + diff --git a/src/desktopportal.h b/src/session.h copy from src/desktopportal.h copy to src/session.h --- a/src/desktopportal.h +++ b/src/session.h @@ -1,5 +1,5 @@ /* - * Copyright © 2016 Red Hat, Inc + * Copyright © 2018 Red Hat, Inc * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,36 +18,35 @@ * Jan Grulich */ -#ifndef XDG_DESKTOP_PORTAL_KDE_DESKTOP_PORTAL_H -#define XDG_DESKTOP_PORTAL_KDE_DESKTOP_PORTAL_H +#ifndef XDG_DESKTOP_PORTAL_KDE_SESSION_H +#define XDG_DESKTOP_PORTAL_KDE_SESSION_H #include #include -#include "access.h" -#include "appchooser.h" -#include "email.h" -#include "filechooser.h" -#include "inhibit.h" -#include "notification.h" -#include "print.h" - -class DesktopPortal : public QObject +class Session : public QDBusVirtualObject { Q_OBJECT public: - explicit DesktopPortal(QObject *parent = nullptr); - ~DesktopPortal(); + explicit Session(QObject *parent = nullptr, const QString &appId = QString(), const QString &path = QString()); + ~Session(); + + bool handleMessage(const QDBusMessage &message, const QDBusConnection &connection) Q_DECL_OVERRIDE; + QString introspect(const QString &path) const Q_DECL_OVERRIDE; + + bool close(); + + bool multipleSources() const; + void setMultipleSources(bool multipleSources); + +Q_SIGNALS: + void closed(); private: - AccessPortal *m_access; - AppChooserPortal *m_appChooser; - EmailPortal *m_email; - FileChooserPortal *m_fileChooser; - InhibitPortal *m_inhibit; - NotificationPortal *m_notification; - PrintPortal *m_print; + bool m_multipleSources; + const QString m_appId; + const QString m_path; }; -#endif // XDG_DESKTOP_PORTAL_KDE_DESKTOP_PORTAL_H +#endif // XDG_DESKTOP_PORTAL_KDE_SESSION_H diff --git a/src/session.cpp b/src/session.cpp new file mode 100644 --- /dev/null +++ b/src/session.cpp @@ -0,0 +1,126 @@ +/* + * Copyright © 2018 Red Hat, Inc + * + * This program 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 of the License, or (at your option) any later version. + * + * 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 . + * + * Authors: + * Jan Grulich + */ + +#include "desktopportal.h" +#include "session.h" + +#include +#include +#include +#include +#include +#include +#include + +Q_LOGGING_CATEGORY(XdgSessionKdeSession, "xdp-kde-session") + +Session::Session(QObject *parent, const QString &appId, const QString &path) + : QDBusVirtualObject(parent) + , m_multipleSources(false) + , m_appId(appId) + , m_path(path) +{ +} + +Session::~Session() +{ +} + +bool Session::handleMessage(const QDBusMessage &message, const QDBusConnection &connection) +{ + Q_UNUSED(connection); + + if (message.path() != m_path) { + return false; + } + + /* Check to make sure we're getting properties on our interface */ + if (message.type() != QDBusMessage::MessageType::MethodCallMessage) { + return false; + } + + qCDebug(XdgSessionKdeSession) << message.interface(); + qCDebug(XdgSessionKdeSession) << message.member(); + qCDebug(XdgSessionKdeSession) << message.path(); + + if (message.interface() == QLatin1String("org.freedesktop.impl.portal.Session")) { + if (message.member() == QLatin1String("Close")) { + Q_EMIT closed(); + QDBusMessage reply = message.createReply(); + return connection.send(reply); + } + } else if (message.interface() == QLatin1String("org.freedesktop.DBus.Properties")) { + if (message.member() == QLatin1String("Get")) { + if (message.arguments().count() == 2) { + const QString interface = message.arguments().at(0).toString(); + const QString property = message.arguments().at(1).toString(); + + if (interface == QLatin1String("org.freedesktop.impl.portal.Session") && + property == QLatin1String("version")) { + QList arguments; + arguments << 1; + + QDBusMessage reply = message.createReply(); + reply.setArguments(arguments); + return connection.send(reply); + } + } + } + } + + return false; +} + +QString Session::introspect(const QString &path) const +{ + QString nodes; + + if (path.startsWith(QLatin1String("/org/freedesktop/portal/desktop/session/"))) { + nodes = QStringLiteral( + "" + " " + " " + "" + "" + "" + ""); + } + + qCDebug(XdgSessionKdeSession) << nodes; + + return nodes; +} + +bool Session::multipleSources() const +{ + return m_multipleSources; +} + +void Session::setMultipleSources(bool multipleSources) +{ + m_multipleSources = multipleSources; +} + +bool Session::close() +{ + QDBusMessage reply = QDBusMessage::createSignal(m_path, QLatin1String("org.freedesktop.impl.portal.Session"), QLatin1String("Closed")); + return QDBusConnection::sessionBus().send(reply); +} + diff --git a/src/xdg-desktop-portal-kde.cpp b/src/xdg-desktop-portal-kde.cpp --- a/src/xdg-desktop-portal-kde.cpp +++ b/src/xdg-desktop-portal-kde.cpp @@ -24,7 +24,7 @@ #include "desktopportal.h" -Q_LOGGING_CATEGORY(XdgDesktopPortalKde, "xdg-desktop-portal-kde") +Q_LOGGING_CATEGORY(XdgDesktopPortalKde, "xdp-kde") int main(int argc, char *argv[]) {