try move screencopy and toplevel export to screenshare manager

Author: ikalco

src/events/Windows.cpp

@@ -22,6 +22,7 @@
 #include "../desktop/LayerSurface.hpp"
 #include "../managers/LayoutManager.hpp"
 #include "../managers/EventManager.hpp"
+#include "../managers/HookSystemManager.hpp"
 #include "../managers/animation/AnimationManager.hpp"
 
 #include <hyprutils/string/String.hpp>

src/helpers/Monitor.cpp

@@ -27,6 +27,7 @@
 #include "../managers/animation/AnimationManager.hpp"
 #include "../managers/animation/DesktopAnimationManager.hpp"
 #include "../managers/input/InputManager.hpp"
+#include "../managers/HookSystemManager.hpp"
 #include "../hyprerror/HyprError.hpp"
 #include "sync/SyncTimeline.hpp"
 #include "time/Time.hpp"

src/managers/ProtocolManager.cpp

@@ -67,6 +67,7 @@
 #include "../protocols/ExtWorkspace.hpp"
 #include "../protocols/ExtDataDevice.hpp"
 #include "../protocols/PointerWarp.hpp"
+#include "HookSystemManager.hpp"
 
 #include "../helpers/Monitor.hpp"
 #include "../render/Renderer.hpp"

src/managers/screenshare/ScreenshareFrame.cpp

@@ -10,9 +10,13 @@
 #include "../../helpers/Monitor.hpp"
 #include "../../desktop/Window.hpp"
 
-CScreenshareFrame::CScreenshareFrame(WP<CScreenshareSession> session, SP<IHLBuffer> buffer, FScreenshareCallback callback) :
-    m_session(session), m_callback(callback), m_buffer(buffer) {
-    ;
+CScreenshareFrame::CScreenshareFrame(WP<CScreenshareSession> session, SP<IHLBuffer> buffer, bool overlayCursor, FScreenshareCallback callback) :
+    m_session(session), m_buffer(buffer), m_overlayCursor(overlayCursor) {
+    m_callback = callback;
+    // m_callback = [callback, session](eScreenshareResult result) {
+    //     if (!session.expired() && callback)
+    //         callback(result);
+    // };
 }
 
 CScreenshareFrame::~CScreenshareFrame() {
@@ -24,7 +28,10 @@ bool CScreenshareFrame::done() const {
     if (m_session.expired() || m_session->m_stopped)
         return true;
 
-    if (m_shared || !m_buffer)
+    if (m_shared)
+        return true;
+
+    if (!m_buffer || !m_buffer->m_resource || !m_buffer->m_resource->good())
         return true;
 
     if (m_session->m_type == SHARE_MONITOR && m_session->m_monitor.expired())
@@ -33,7 +40,7 @@ bool CScreenshareFrame::done() const {
     if (m_session->m_type == SHARE_REGION && m_session->m_monitor.expired())
         return true;
 
-    if (m_session->m_type == SHARE_WINDOW && (m_session->m_monitor.expired() || m_session->m_window.expired() || m_session->m_window->m_monitor.expired()))
+    if (m_session->m_type == SHARE_WINDOW && (m_session->m_monitor.expired() || !validMapped(m_session->m_window)))
         return true;
 
     return false;
@@ -59,7 +66,7 @@ void CScreenshareFrame::share() {
 }
 
 void CScreenshareFrame::renderMonitor() {
-    if (m_session->m_type != SHARE_MONITOR || done())
+    if ((m_session->m_type != SHARE_MONITOR && m_session->m_type != SHARE_REGION) || done())
         return;
 
     const auto PMONITOR = m_session->m_monitor.lock();
@@ -137,7 +144,7 @@ void CScreenshareFrame::renderMonitor() {
             nullptr);
     }
 
-    if (m_session->m_overlayCursor) {
+    if (m_overlayCursor) {
         CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
         g_pPointerManager->renderSoftwareCursorsFor(PMONITOR, Time::steadyNow(), fakeDamage,
                                                     g_pInputManager->getMouseCoordsInternal() - PMONITOR->m_position - m_session->m_box.pos() / PMONITOR->m_scale, true);
@@ -157,10 +164,21 @@ void CScreenshareFrame::renderWindow() {
     g_pHyprRenderer->renderWindow(PWINDOW, PMONITOR, NOW, false, RENDER_PASS_ALL, true, true);
     g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
 
-    if (m_session->m_overlayCursor) {
-        CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
-        g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), NOW, fakeDamage, g_pInputManager->getMouseCoordsInternal() - PWINDOW->m_realPosition->value());
-    }
+    if (!m_overlayCursor)
+        return;
+
+    auto pointerSurfaceResource = g_pSeatManager->m_state.pointerFocus.lock();
+
+    if (!pointerSurfaceResource)
+        return;
+
+    auto pointerSurface = CWLSurface::fromResource(pointerSurfaceResource);
+
+    if (!pointerSurface || pointerSurface->getWindow() != m_session->m_window)
+        return;
+
+    CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
+    g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), NOW, fakeDamage, g_pInputManager->getMouseCoordsInternal() - PWINDOW->m_realPosition->value());
 }
 
 void CScreenshareFrame::render() {
@@ -186,13 +204,16 @@ void CScreenshareFrame::render() {
     }
 
     switch (m_session->m_type) {
+        case SHARE_REGION: // TODO: could this be better? this is how screencopy works
         case SHARE_MONITOR: renderMonitor(); break;
         case SHARE_WINDOW: renderWindow(); break;
-        case SHARE_REGION: break; // TODO
     }
 }
 
 bool CScreenshareFrame::copyDmabuf() {
+    if (done())
+        return false;
+
     CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
 
     if (!g_pHyprRenderer->beginRender(m_session->m_monitor.lock(), fakeDamage, RENDER_MODE_TO_BUFFER, m_buffer, nullptr, true)) {
@@ -213,6 +234,9 @@ bool CScreenshareFrame::copyDmabuf() {
 }
 
 bool CScreenshareFrame::copyShm() {
+    if (done())
+        return false;
+
     g_pHyprRenderer->makeEGLCurrent();
 
     auto shm                      = m_buffer->shm();
@@ -286,9 +310,9 @@ void CScreenshareFrame::storeTempFB() {
     }
 
     switch (m_session->m_type) {
+        case SHARE_REGION: // TODO: could this be better? this is how screencopy works
         case SHARE_MONITOR: renderMonitor(); break;
         case SHARE_WINDOW: renderWindow(); break;
-        case SHARE_REGION: break; // TODO
     }
 
     g_pHyprRenderer->endRender();

src/managers/screenshare/ScreenshareManager.cpp

@@ -2,9 +2,14 @@
 #include "../../render/Renderer.hpp"
 #include "../../Compositor.hpp"
 #include "../../desktop/Window.hpp"
+#include "../HookSystemManager.hpp"
+#include "../EventManager.hpp"
+#include "../eventLoop/EventLoopManager.hpp"
 
 CScreenshareManager::CScreenshareManager() {
-    ;
+    m_tickTimer = makeShared<CEventLoopTimer>(std::chrono::microseconds(500), [this](SP<CEventLoopTimer> self, void* data) { onTick(); }, nullptr);
+    if (g_pEventLoopManager) // null in --verify-config mode
+        g_pEventLoopManager->addTimer(m_tickTimer);
 }
 
 void CScreenshareManager::onOutputCommit(PHLMONITOR monitor) {
@@ -13,54 +18,167 @@ void CScreenshareManager::onOutputCommit(PHLMONITOR monitor) {
         return; // nothing to share
     }
 
-    std::ranges::remove_if(m_sessions, [&](const WP<CScreenshareSession>& session) { return session.expired(); });
+    LOGM(LOG, "1 onOutputCommit for {}, s {}, ms {}, f {}", monitor->m_name, m_sessions.size(), m_managedSessions.size(), m_frames.size());
+
+    std::erase_if(m_sessions, [&](const WP<CScreenshareSession>& session) { return session.expired(); });
+
+    LOGM(LOG, "2 onOutputCommit for {}, s {}, ms {}, f {}", monitor->m_name, m_sessions.size(), m_managedSessions.size(), m_frames.size());
 
     std::ranges::for_each(m_frames, [&](UP<CScreenshareFrame>& frame) {
-        if (!frame->done())
-            frame->share();
+        if (!frame || frame->done())
+            return;
+
+        if (frame->m_session->m_monitor != monitor)
+            return;
+
+        if (frame->m_session->m_type == SHARE_WINDOW) {
+            CBox geometry = {frame->m_session->m_window->m_realPosition->value(), frame->m_session->m_window->m_realSize->value()};
+            if (geometry.intersection({monitor->m_position, monitor->m_size}).empty())
+                return;
+        }
+
+        frame->share();
+        frame->m_session->m_lastFrame.reset();
+        frame->m_session->m_frameCounter++;
     });
 
-    std::ranges::remove_if(m_frames, [&](const UP<CScreenshareFrame>& frame) { return frame->done(); });
+    std::erase_if(m_frames, [&](const UP<CScreenshareFrame>& frame) { return !frame || frame->done(); });
+
+    LOGM(LOG, "3 onOutputCommit for {}, s {}, ms {}, f {}", monitor->m_name, m_sessions.size(), m_managedSessions.size(), m_frames.size());
 }
 
-UP<CScreenshareSession> CScreenshareManager::newSession(PHLMONITOR monitor, wl_client* client, bool overlayCursor) {
+void CScreenshareManager::onTick() {
+    m_tickTimer->updateTimeout(std::chrono::microseconds(500));
+
+    std::ranges::for_each(m_managedSessions, [this](auto& session) {
+        if (session->m_lastMeasure.getMillis() < 500)
+            return;
+
+        session->m_framesInLastHalfSecond  = session->m_session->m_frameCounter;
+        session->m_session->m_frameCounter = 0;
+        session->m_lastMeasure.reset();
+
+        const auto LASTFRAMEDELTA = session->m_session->m_lastFrame.getMillis() / 1000.0;
+        const bool FRAMEAWAITING  = std::ranges::any_of(m_frames, [&](const auto& frame) { return frame->m_session->m_client == session->m_session->m_client; });
+
+        if (session->m_framesInLastHalfSecond > 3 && !session->m_sentScreencast) {
+            screenshareStarted(session->m_session);
+            session->m_sentScreencast = true;
+        } else if (session->m_framesInLastHalfSecond < 4 && LASTFRAMEDELTA > 1.0 && !FRAMEAWAITING) {
+            session->m_session->stop();
+            session->m_sentScreencast = false;
+        }
+    });
+}
+
+void CScreenshareManager::screenshareStarted(WP<CScreenshareSession> session) {
+    EMIT_HOOK_EVENT("screencastv2", (std::vector<std::any>{1, session->m_type, session->m_name}));
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "screencastv2", .data = std::format("1,{},{}", session->m_type, session->m_name)});
+    LOGM(LOG, "New screenshare session for ({}): {}", session->m_type, session->m_name);
+}
+
+UP<CScreenshareSession> CScreenshareManager::newSession(PHLMONITOR monitor, wl_client* client) {
     if UNLIKELY (!monitor || !g_pCompositor->monitorExists(monitor)) {
         LOGM(ERR, "Client requested sharing of a monitor that is gone");
         return nullptr;
     }
 
-    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(monitor, client, overlayCursor));
+    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(monitor, client));
 
     session->m_self = session;
     m_sessions.emplace_back(session);
 
+    screenshareStarted(session);
+
     return session;
 }
 
-UP<CScreenshareSession> CScreenshareManager::newSession(PHLMONITOR monitor, CBox captureRegion, wl_client* client, bool overlayCursor) {
+UP<CScreenshareSession> CScreenshareManager::newSession(PHLMONITOR monitor, CBox captureRegion, wl_client* client) {
     if UNLIKELY (!monitor || !g_pCompositor->monitorExists(monitor)) {
         LOGM(ERR, "Client requested sharing of a monitor that is gone");
         return nullptr;
     }
 
-    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(monitor, captureRegion, client, overlayCursor));
+    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(monitor, captureRegion, client));
 
     session->m_self = session;
     m_sessions.emplace_back(session);
 
+    screenshareStarted(session);
+
     return session;
 }
 
-UP<CScreenshareSession> CScreenshareManager::newSession(PHLWINDOW window, wl_client* client, bool overlayCursor) {
+UP<CScreenshareSession> CScreenshareManager::newSession(PHLWINDOW window, wl_client* client) {
     if UNLIKELY (!window || !window->m_isMapped) {
         LOGM(ERR, "Client requested sharing of window that is gone or not shareable!");
         return nullptr;
     }
 
-    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(window, client, overlayCursor));
+    UP<CScreenshareSession> session = UP<CScreenshareSession>(new CScreenshareSession(window, client));
 
     session->m_self = session;
     m_sessions.emplace_back(session);
 
+    screenshareStarted(session);
+
     return session;
 }
+
+WP<CScreenshareSession> CScreenshareManager::getManagedSession(wl_client* client, PHLMONITOR monitor) {
+    return getManagedSession(SHARE_MONITOR, client, monitor, nullptr, {});
+}
+
+WP<CScreenshareSession> CScreenshareManager::getManagedSession(wl_client* client, PHLMONITOR monitor, CBox captureBox) {
+
+    return getManagedSession(SHARE_REGION, client, monitor, nullptr, captureBox);
+}
+
+WP<CScreenshareSession> CScreenshareManager::getManagedSession(wl_client* client, PHLWINDOW window) {
+    return getManagedSession(SHARE_WINDOW, client, nullptr, window, {});
+}
+
+WP<CScreenshareSession> CScreenshareManager::getManagedSession(eScreenshareType type, wl_client* client, PHLMONITOR monitor, PHLWINDOW window, CBox captureBox) {
+    auto it = std::ranges::find_if(m_managedSessions, [&](const auto& session) {
+        if (session->m_session->m_client != client || session->m_session->m_type != type)
+            return false;
+
+        switch (type) {
+            case SHARE_MONITOR: return session->m_session->m_monitor == monitor;
+            case SHARE_WINDOW: return session->m_session->m_window == window;
+            case SHARE_REGION: return session->m_session->m_monitor == monitor && session->m_session->m_captureBox == captureBox;
+        }
+
+        return false;
+    });
+
+    if (it == m_managedSessions.end()) {
+        UP<CScreenshareSession> session;
+        switch (type) {
+            case SHARE_MONITOR: session = UP<CScreenshareSession>(new CScreenshareSession(monitor, client)); break;
+            case SHARE_WINDOW: session = UP<CScreenshareSession>(new CScreenshareSession(window, client)); break;
+            case SHARE_REGION: session = UP<CScreenshareSession>(new CScreenshareSession(monitor, captureBox, client)); break;
+        }
+
+        session->m_self = session;
+        m_sessions.emplace_back(session);
+
+        it = m_managedSessions.emplace(m_managedSessions.end(), makeUnique<SManagedSession>(std::move(session)));
+    }
+
+    auto& session = *it;
+
+    session->stoppedListener = session->m_session->m_events.stopped.listen(
+        [&]() { std::erase_if(m_managedSessions, [&](const auto& s) { return !s || !session || s->m_session == session->m_session; }); });
+
+    return session->m_session;
+}
+
+void CScreenshareManager::destroyClientSessions(wl_client* client) {
+    LOGM(LOG, "destroy client sessions for {:x}", (uintptr_t)client);
+    std::erase_if(m_managedSessions, [&](const auto& session) { return !session || session->m_session->m_client == client; });
+}
+
+CScreenshareManager::SManagedSession::SManagedSession(UP<CScreenshareSession> session) : m_session(std::move(session)) {
+    m_lastMeasure.reset();
+}