implement image copy capture cursor session

squashed from
* implement 1st half of image copy capture cursor session
* add cursor pos permission for image copy capture cursor session
* add cursor share session
* implement cursor copy capture session

Author: ikalco

src/config/ConfigManager.cpp

@@ -3147,6 +3147,8 @@ std::optional<std::string> CConfigManager::handlePermission(const std::string& c
         type = PERMISSION_TYPE_PLUGIN;
     else if (data[1] == "keyboard" || data[1] == "keeb")
         type = PERMISSION_TYPE_KEYBOARD;
+    else if (data[1] == "cursorpos" || data[1] == "cursor")
+        type = PERMISSION_TYPE_CURSOR;
 
     if (data[2] == "ask")
         mode = PERMISSION_RULE_ALLOW_MODE_ASK;

src/managers/permissions/DynamicPermissionManager.cpp

@@ -52,6 +52,7 @@ static const char* permissionToString(eDynamicPermissionType type) {
         case PERMISSION_TYPE_SCREENCOPY: return "PERMISSION_TYPE_SCREENCOPY";
         case PERMISSION_TYPE_PLUGIN: return "PERMISSION_TYPE_PLUGIN";
         case PERMISSION_TYPE_KEYBOARD: return "PERMISSION_TYPE_KEYBOARD";
+        case PERMISSION_TYPE_CURSOR: return "PERMISSION_TYPE_CURSOR_POS";
     }
 
     return "error";
@@ -63,6 +64,8 @@ static const char* permissionToHumanString(eDynamicPermissionType type) {
         case PERMISSION_TYPE_SCREENCOPY: return "An application <b>{}</b> is trying to capture your screen.<br/><br/>Do you want to allow it to do so?";
         case PERMISSION_TYPE_PLUGIN: return "An application <b>{}</b> is trying to load a plugin: <b>{}</b>.<br/><br/>Do you want to load it?";
         case PERMISSION_TYPE_KEYBOARD: return "A new keyboard has been plugged in: {}.<br/><br/>Do you want to allow it to operate?";
+        case PERMISSION_TYPE_CURSOR:
+            return "An application <b>{}</b> is trying to capture the position of the cursor when it's inside the application.<br/><br/>Do you want to allow it to do so?";
     }
 
     return "error";

src/managers/permissions/DynamicPermissionManager.hpp

@@ -18,6 +18,7 @@ enum eDynamicPermissionType : uint8_t {
     PERMISSION_TYPE_SCREENCOPY,
     PERMISSION_TYPE_PLUGIN,
     PERMISSION_TYPE_KEYBOARD,
+    PERMISSION_TYPE_CURSOR,
 };
 
 enum eDynamicPermissionRuleSource : uint8_t {
@@ -104,4 +105,4 @@ class CDynamicPermissionManager {
     std::vector<SP<CDynamicPermissionRule>> m_rules;
 };
 
-inline UP<CDynamicPermissionManager> g_pDynamicPermissionManager;
+inline UP<CDynamicPermissionManager> g_pDynamicPermissionManager;

src/managers/screenshare/CursorshareSession.cpp

@@ -0,0 +1,149 @@
+#include "ScreenshareManager.hpp"
+#include "../PointerManager.hpp"
+#include "../../protocols/core/Seat.hpp"
+#include "../permissions/DynamicPermissionManager.hpp"
+#include "../../render/Renderer.hpp"
+
+#include <cstring>
+
+CCursorshareSession::CCursorshareSession(wl_client* client, WP<CWLPointerResource> pointer) : m_client(client), m_pointer(pointer) {
+    m_listeners.pointerDestroyed = m_pointer->m_events.destroyed.listen([this] { stop(); });
+    m_listeners.cursorChanged    = g_pPointerManager->m_events.cursorChanged.listen([this] {
+        calculateConstraints();
+        m_events.constraintsChanged.emit();
+    });
+
+    calculateConstraints();
+}
+
+CCursorshareSession::~CCursorshareSession() {
+    stop();
+}
+
+void CCursorshareSession::stop() {
+    if (m_stopped)
+        return;
+    m_stopped = true;
+    m_events.stopped.emit();
+}
+
+void CCursorshareSession::calculateConstraints() {
+    const auto& cursorImage = g_pPointerManager->currentCursorImage();
+
+    // TODO: should cursor share have a format bit flip for RGBA?
+    if (auto attrs = cursorImage.pBuffer->shm(); attrs.success) {
+        m_format = attrs.format;
+    } else {
+        // we only have shm cursors
+        return;
+    }
+
+    m_hotspot    = cursorImage.hotspot;
+    m_bufferSize = cursorImage.size;
+}
+
+// TODO: allow render to buffer without monitor and remove monitor param
+eScreenshareError CCursorshareSession::share(PHLMONITOR monitor, SP<IHLBuffer> buffer, FScreenshareCallback callback) {
+    if (m_stopped || m_pointer.expired())
+        return ERROR_STOPPED;
+
+    if UNLIKELY (!buffer || !buffer->m_resource || !buffer->m_resource->good()) {
+        LOGM(ERR, "Client requested sharing to an invalid buffer");
+        return ERROR_NO_BUFFER;
+    }
+
+    if UNLIKELY (buffer->size != m_bufferSize) {
+        LOGM(ERR, "Client requested sharing to an invalid buffer size");
+        return ERROR_BUFFER_SIZE;
+    }
+
+    if (auto attrs = buffer->dmabuf(); attrs.success && attrs.format != m_format) {
+        LOGM(ERR, "Invalid dmabuf format {} in {:x}", attrs.format, (uintptr_t)this);
+        return ERROR_BUFFER_FORMAT;
+    } else if (auto attrs = buffer->shm(); attrs.success && attrs.format != m_format) {
+        LOGM(ERR, "Invalid shm format {} in {:x}", attrs.format, (uintptr_t)this);
+        return ERROR_BUFFER_FORMAT;
+    } else {
+        LOGM(ERR, "Client requested sharing to an invalid buffer");
+        return ERROR_NO_BUFFER;
+    }
+
+    if (!copy(monitor, buffer, callback)) {
+        callback(RESULT_NOT_COPIED);
+        return ERROR_UNKNOWN;
+    }
+
+    return ERROR_NONE;
+}
+
+bool CCursorshareSession::copy(PHLMONITOR monitor, SP<IHLBuffer> buffer, FScreenshareCallback callback) {
+    const auto& cursorImage = g_pPointerManager->currentCursorImage();
+
+    const auto  PERM = g_pDynamicPermissionManager->clientPermissionMode(m_client, PERMISSION_TYPE_CURSOR);
+    if (PERM != PERMISSION_RULE_ALLOW_MODE_PENDING && PERM != PERMISSION_RULE_ALLOW_MODE_ALLOW)
+        return false;
+
+    // FIXME: this doesn't really make sense but just to be safe
+    callback(RESULT_TIMESTAMP);
+
+    if (auto attrs = buffer->dmabuf(); attrs.success) {
+        if (attrs.format != m_format)
+            return false;
+
+        CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
+
+        if (!g_pHyprRenderer->beginRender(monitor, fakeDamage, RENDER_MODE_TO_BUFFER, buffer, nullptr, true)) {
+            LOGM(ERR, "Can't copy: failed to begin rendering to dma frame");
+            return false;
+        }
+
+        if (cursorImage.surface && cursorImage.bufferTex && PERM != PERMISSION_RULE_ALLOW_MODE_PENDING) {
+            CBox texbox = {{}, cursorImage.bufferTex->m_size};
+            g_pHyprOpenGL->renderTexture(cursorImage.bufferTex, texbox, {});
+        } else {
+            g_pHyprOpenGL->clear(Colors::BLACK);
+        }
+
+        g_pHyprOpenGL->m_renderData.blockScreenShader = true;
+
+        g_pHyprRenderer->endRender([callback]() {
+            if (callback)
+                callback(RESULT_COPIED);
+        });
+    } else if (auto attrs = buffer->shm(); attrs.success) {
+        auto [bufData, fmt, bufLen] = buffer->beginDataPtr(0);
+
+        if (cursorImage.surface && cursorImage.pBuffer && PERM != PERMISSION_RULE_ALLOW_MODE_PENDING) {
+            // we have to copy from gpu if we render this anyway, so dont render and just copy
+            auto [cursorPixelData, cursorFmt, cursorBufLen] = cursorImage.pBuffer->beginDataPtr(0);
+
+            if (fmt != m_format || fmt != cursorFmt || bufLen != cursorBufLen)
+                return false;
+
+            memcpy(bufData, cursorPixelData, bufLen);
+
+            buffer->endDataPtr();
+            cursorImage.pBuffer->endDataPtr();
+
+        } else {
+            memset(bufData, 0, bufLen);
+        }
+
+        callback(RESULT_COPIED);
+    } else
+        return false;
+
+    return true;
+}
+
+DRMFormat CCursorshareSession::format() const {
+    return m_format;
+}
+
+Vector2D CCursorshareSession::bufferSize() const {
+    return m_bufferSize;
+}
+
+Vector2D CCursorshareSession::hotspot() const {
+    return m_hotspot;
+}

src/managers/screenshare/ScreenshareManager.cpp

@@ -5,6 +5,7 @@
 #include "../HookSystemManager.hpp"
 #include "../EventManager.hpp"
 #include "../eventLoop/EventLoopManager.hpp"
+#include "../../protocols/core/Seat.hpp"
 
 CScreenshareManager::CScreenshareManager() {
     m_tickTimer = makeShared<CEventLoopTimer>(std::chrono::microseconds(500), [this](SP<CEventLoopTimer> self, void* data) { onTick(); }, nullptr);
@@ -129,6 +130,15 @@ UP<CScreenshareSession> CScreenshareManager::newSession(wl_client* client, PHLWI
     return session;
 }
 
+UP<CCursorshareSession> CScreenshareManager::newCursorSession(wl_client* client, WP<CWLPointerResource> pointer) {
+    UP<CCursorshareSession> session = UP<CCursorshareSession>(new CCursorshareSession(client, pointer));
+
+    session->m_self = session;
+    m_cursorSessions.emplace_back(session);
+
+    return session;
+}
+
 WP<CScreenshareSession> CScreenshareManager::getManagedSession(wl_client* client, PHLMONITOR monitor) {
     return getManagedSession(SHARE_MONITOR, client, monitor, nullptr, {});
 }

src/managers/screenshare/ScreenshareManager.hpp

@@ -45,6 +45,7 @@ struct std::formatter<eScreenshareType> : std::formatter<std::string> {
 using FScreenshareCallback = std::function<void(eScreenshareResult result)>;
 
 class CScreenshareFrame;
+class CWLPointerResource;
 
 class CScreenshareSession {
   public:
@@ -105,6 +106,51 @@ class CScreenshareSession {
     friend class CScreenshareManager;
 };
 
+class CCursorshareSession {
+  public:
+    CCursorshareSession(const CCursorshareSession&) = delete;
+    CCursorshareSession(CCursorshareSession&&)      = delete;
+    ~CCursorshareSession();
+
+    eScreenshareError share(PHLMONITOR monitor, SP<IHLBuffer> buffer, FScreenshareCallback callback);
+    void              stop();
+
+    // constraints
+    DRMFormat format() const;
+    Vector2D  bufferSize() const;
+    Vector2D  hotspot() const;
+
+    struct {
+        CSignalT<> stopped;
+        CSignalT<> constraintsChanged;
+    } m_events;
+
+  private:
+    CCursorshareSession(wl_client* client, WP<CWLPointerResource> pointer);
+
+    WP<CCursorshareSession> m_self;
+    bool                    m_stopped = false;
+
+    wl_client*              m_client;
+    WP<CWLPointerResource>  m_pointer;
+
+    // constraints
+    DRMFormat m_format;
+    Vector2D  m_hotspot;
+    Vector2D  m_bufferSize;
+
+    struct {
+        CHyprSignalListener pointerDestroyed;
+        CHyprSignalListener cursorChanged;
+    } m_listeners;
+
+    bool copy(PHLMONITOR monitor, SP<IHLBuffer> buffer, FScreenshareCallback callback);
+    void calculateConstraints();
+
+    friend class CScreenshareFrame;
+    friend class CScreenshareManager;
+};
+
 class CScreenshareFrame {
   public:
     CScreenshareFrame(const CScreenshareFrame&) = delete;
@@ -158,12 +204,15 @@ class CScreenshareManager {
     WP<CScreenshareSession> getManagedSession(wl_client* client, PHLMONITOR monitor, CBox captureBox);
     WP<CScreenshareSession> getManagedSession(wl_client* client, PHLWINDOW window);
 
+    UP<CCursorshareSession> newCursorSession(wl_client* client, WP<CWLPointerResource> pointer);
+
     void                    destroyClientSessions(wl_client* client);
 
     void                    onOutputCommit(PHLMONITOR monitor);
 
   private:
     std::vector<WP<CScreenshareSession>> m_sessions;
+    std::vector<WP<CCursorshareSession>> m_cursorSessions;
     std::vector<WP<CScreenshareFrame>>   m_frames;
 
     struct SManagedSession {

src/protocols/ImageCaptureSource.hpp

@@ -26,6 +26,7 @@ class CImageCaptureSource {
     PHLWINDOWREF                 m_window;
 
     friend class CImageCopyCaptureSession;
+    friend class CImageCopyCaptureCursorSession;
 };
 
 class COutputImageCaptureSourceProtocol : public IWaylandProtocol {