protocols: implement image-capture-source-v1 and image-copy-capture-v1 (#11709)

Implements the new screencopy protocols

1 files changed, 83 insertions, 394 deletions

diff --git a/src/protocols/ToplevelExport.cpp b/src/protocols/ToplevelExport.cpp
index b223f778..3b8973ab 100644
--- a/src/protocols/ToplevelExport.cpp
+++ b/src/protocols/ToplevelExport.cpp
@@ -1,41 +1,44 @@
 #include "ToplevelExport.hpp"
 #include "../Compositor.hpp"
 #include "ForeignToplevelWlr.hpp"
-#include "../managers/PointerManager.hpp"
-#include "../managers/SeatManager.hpp"
-#include "types/WLBuffer.hpp"
-#include "types/Buffer.hpp"
+#include "../managers/screenshare/ScreenshareManager.hpp"
+#include "../managers/HookSystemManager.hpp"
 #include "../helpers/Format.hpp"
-#include "../managers/EventManager.hpp"
-#include "../managers/input/InputManager.hpp"
-#include "../managers/permissions/DynamicPermissionManager.hpp"
 #include "../render/Renderer.hpp"
 
-#include <algorithm>
 #include <hyprutils/math/Vector2D.hpp>
 
+using namespace Screenshare;
+
 CToplevelExportClient::CToplevelExportClient(SP<CHyprlandToplevelExportManagerV1> resource_) : m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    m_resource->setOnDestroy([this](CHyprlandToplevelExportManagerV1* pMgr) { PROTO::toplevelExport->destroyResource(this); });
+    m_resource->setOnDestroy([this](CHyprlandToplevelExportManagerV1* pMgr) {
+        Screenshare::mgr()->destroyClientSessions(m_savedClient);
+        PROTO::toplevelExport->destroyResource(this);
+    });
     m_resource->setDestroy([this](CHyprlandToplevelExportManagerV1* pMgr) { PROTO::toplevelExport->destroyResource(this); });
     m_resource->setCaptureToplevel([this](CHyprlandToplevelExportManagerV1* pMgr, uint32_t frame, int32_t overlayCursor, uint32_t handle) {
-        this->captureToplevel(pMgr, frame, overlayCursor, g_pCompositor->getWindowFromHandle(handle));
+        captureToplevel(frame, overlayCursor, g_pCompositor->getWindowFromHandle(handle));
     });
     m_resource->setCaptureToplevelWithWlrToplevelHandle([this](CHyprlandToplevelExportManagerV1* pMgr, uint32_t frame, int32_t overlayCursor, wl_resource* handle) {
-        this->captureToplevel(pMgr, frame, overlayCursor, PROTO::foreignToplevelWlr->windowFromHandleResource(handle));
+        captureToplevel(frame, overlayCursor, PROTO::foreignToplevelWlr->windowFromHandleResource(handle));
     });
 
-    m_lastMeasure.reset();
-    m_lastFrame.reset();
-    m_tickCallback = g_pHookSystem->hookDynamic("tick", [&](void* self, SCallbackInfo& info, std::any data) { onTick(); });
+    m_savedClient = m_resource->client();
+}
+
+CToplevelExportClient::~CToplevelExportClient() {
+    Screenshare::mgr()->destroyClientSessions(m_savedClient);
 }
 
-void CToplevelExportClient::captureToplevel(CHyprlandToplevelExportManagerV1* pMgr, uint32_t frame, int32_t overlayCursor_, PHLWINDOW handle) {
+void CToplevelExportClient::captureToplevel(uint32_t frame, int32_t overlayCursor_, PHLWINDOW handle) {
+    auto session = Screenshare::mgr()->getManagedSession(m_resource->client(), handle);
+
     // create a frame
     const auto FRAME = PROTO::toplevelExport->m_frames.emplace_back(
-        makeShared<CToplevelExportFrame>(makeShared<CHyprlandToplevelExportFrameV1>(m_resource->client(), m_resource->version(), frame), overlayCursor_, handle));
+        makeShared<CToplevelExportFrame>(makeShared<CHyprlandToplevelExportFrameV1>(m_resource->client(), m_resource->version(), frame), session, !!overlayCursor_));
 
     if UNLIKELY (!FRAME->good()) {
         LOGM(Log::ERR, "Couldn't alloc frame for sharing! (no memory)");
@@ -44,370 +47,115 @@ void CToplevelExportClient::captureToplevel(CHyprlandToplevelExportManagerV1* pM
         return;
     }
 
-    FRAME->m_self   = FRAME;
     FRAME->m_client = m_self;
-}
-
-void CToplevelExportClient::onTick() {
-    if (m_lastMeasure.getMillis() < 500)
-        return;
-
-    m_framesInLastHalfSecond = m_frameCounter;
-    m_frameCounter           = 0;
-    m_lastMeasure.reset();
-
-    const auto LASTFRAMEDELTA = m_lastFrame.getMillis() / 1000.0;
-    const bool FRAMEAWAITING  = std::ranges::any_of(PROTO::toplevelExport->m_frames, [&](const auto& frame) { return frame->m_client.get() == this; });
-
-    if (m_framesInLastHalfSecond > 3 && !m_sentScreencast) {
-        EMIT_HOOK_EVENT("screencast", (std::vector<uint64_t>{1, sc<uint64_t>(m_framesInLastHalfSecond), sc<uint64_t>(m_clientOwner)}));
-        g_pEventManager->postEvent(SHyprIPCEvent{"screencast", "1," + std::to_string(m_clientOwner)});
-        m_sentScreencast = true;
-    } else if (m_framesInLastHalfSecond < 4 && m_sentScreencast && LASTFRAMEDELTA > 1.0 && !FRAMEAWAITING) {
-        EMIT_HOOK_EVENT("screencast", (std::vector<uint64_t>{0, sc<uint64_t>(m_framesInLastHalfSecond), sc<uint64_t>(m_clientOwner)}));
-        g_pEventManager->postEvent(SHyprIPCEvent{"screencast", "0," + std::to_string(m_clientOwner)});
-        m_sentScreencast = false;
-    }
+    FRAME->m_self   = FRAME;
 }
 
 bool CToplevelExportClient::good() {
-    return m_resource->resource();
+    return m_resource && m_resource->resource();
 }
 
-CToplevelExportFrame::CToplevelExportFrame(SP<CHyprlandToplevelExportFrameV1> resource_, int32_t overlayCursor_, PHLWINDOW pWindow_) : m_resource(resource_), m_window(pWindow_) {
+CToplevelExportFrame::CToplevelExportFrame(SP<CHyprlandToplevelExportFrameV1> resource_, WP<CScreenshareSession> session, bool overlayCursor) :
+    m_resource(resource_), m_session(session) {
     if UNLIKELY (!good())
         return;
 
-    m_cursorOverlayRequested = !!overlayCursor_;
-
-    if UNLIKELY (!m_window) {
-        LOGM(Log::ERR, "Client requested sharing of window handle {:x} which does not exist!", m_window);
-        m_resource->sendFailed();
-        return;
-    }
-
-    if UNLIKELY (!m_window->m_isMapped) {
-        LOGM(Log::ERR, "Client requested sharing of window handle {:x} which is not shareable!", m_window);
-        m_resource->sendFailed();
-        return;
-    }
-
     m_resource->setOnDestroy([this](CHyprlandToplevelExportFrameV1* pFrame) { PROTO::toplevelExport->destroyResource(this); });
     m_resource->setDestroy([this](CHyprlandToplevelExportFrameV1* pFrame) { PROTO::toplevelExport->destroyResource(this); });
-    m_resource->setCopy([this](CHyprlandToplevelExportFrameV1* pFrame, wl_resource* res, int32_t ignoreDamage) { this->copy(pFrame, res, ignoreDamage); });
-
-    const auto PMONITOR = m_window->m_monitor.lock();
+    m_resource->setCopy([this](CHyprlandToplevelExportFrameV1* pFrame, wl_resource* res, int32_t ignoreDamage) { shareFrame(res, !!ignoreDamage); });
 
-    g_pHyprRenderer->makeEGLCurrent();
+    m_listeners.stopped = m_session->m_events.stopped.listen([this]() {
+        if (good())
+            m_resource->sendFailed();
+    });
 
-    m_shmFormat = NFormatUtils::alphaFormat(g_pHyprOpenGL->getPreferredReadFormat(PMONITOR));
-    LOGM(Log::DEBUG, "Format {:x}", m_shmFormat);
-    //m_shmFormat = NFormatUtils::alphaFormat(m_shmFormat);
-    if UNLIKELY (m_shmFormat == DRM_FORMAT_INVALID) {
-        LOGM(Log::ERR, "No format supported by renderer in capture toplevel");
-        m_resource->sendFailed();
-        return;
-    }
+    m_frame = m_session->nextFrame(overlayCursor);
 
-    const auto PSHMINFO = NFormatUtils::getPixelFormatFromDRM(m_shmFormat);
-    if UNLIKELY (!PSHMINFO) {
-        LOGM(Log::ERR, "No pixel format supported by renderer in capture toplevel");
+    auto formats = m_session->allowedFormats();
+    if (formats.empty()) {
+        LOGM(Log::ERR, "No format supported by renderer in toplevel export protocol");
         m_resource->sendFailed();
         return;
     }
 
-    m_dmabufFormat = NFormatUtils::alphaFormat(g_pHyprOpenGL->getPreferredReadFormat(PMONITOR));
-
-    m_box = {0, 0, sc<int>(m_window->m_realSize->value().x * PMONITOR->m_scale), sc<int>(m_window->m_realSize->value().y * PMONITOR->m_scale)};
-
-    m_box.transform(Math::wlTransformToHyprutils(PMONITOR->m_transform), PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y).round();
+    DRMFormat  format  = formats.at(0);
+    auto       bufSize = m_frame->bufferSize();
 
-    m_shmStride = NFormatUtils::minStride(PSHMINFO, m_box.w);
+    const auto PSHMINFO = NFormatUtils::getPixelFormatFromDRM(format);
+    const auto stride   = NFormatUtils::minStride(PSHMINFO, bufSize.x);
+    m_resource->sendBuffer(NFormatUtils::drmToShm(format), bufSize.x, bufSize.y, stride);
 
-    m_resource->sendBuffer(NFormatUtils::drmToShm(m_shmFormat), m_box.width, m_box.height, m_shmStride);
-
-    if LIKELY (m_dmabufFormat != DRM_FORMAT_INVALID)
-        m_resource->sendLinuxDmabuf(m_dmabufFormat, m_box.width, m_box.height);
+    if LIKELY (format != DRM_FORMAT_INVALID)
+        m_resource->sendLinuxDmabuf(format, bufSize.x, bufSize.y);
 
     m_resource->sendBufferDone();
 }
 
-void CToplevelExportFrame::copy(CHyprlandToplevelExportFrameV1* pFrame, wl_resource* buffer_, int32_t ignoreDamage) {
-    if UNLIKELY (!good()) {
-        LOGM(Log::ERR, "No frame in copyFrame??");
-        return;
-    }
-
-    if UNLIKELY (!validMapped(m_window)) {
-        LOGM(Log::ERR, "Client requested sharing of window handle {:x} which is gone!", m_window);
-        m_resource->sendFailed();
-        return;
-    }
-
-    if UNLIKELY (!m_window->m_isMapped) {
-        LOGM(Log::ERR, "Client requested sharing of window handle {:x} which is not shareable (2)!", m_window);
-        m_resource->sendFailed();
-        return;
-    }
-
-    const auto PBUFFER = CWLBufferResource::fromResource(buffer_);
-    if UNLIKELY (!PBUFFER) {
-        m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer");
-        PROTO::toplevelExport->destroyResource(this);
-        return;
-    }
+bool CToplevelExportFrame::good() {
+    return m_resource && m_resource->resource();
+}
 
-    if UNLIKELY (PBUFFER->m_buffer->size != m_box.size()) {
-        m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer dimensions");
-        PROTO::toplevelExport->destroyResource(this);
+void CToplevelExportFrame::shareFrame(wl_resource* buffer, bool ignoreDamage) {
+    if UNLIKELY (!good()) {
+        LOGM(Log::ERR, "No frame in shareFrame??");
         return;
     }
 
     if UNLIKELY (m_buffer) {
+        LOGM(Log::ERR, "Buffer used in {:x}", (uintptr_t)this);
         m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_ALREADY_USED, "frame already used");
-        PROTO::toplevelExport->destroyResource(this);
+        m_resource->sendFailed();
         return;
     }
 
-    if (auto attrs = PBUFFER->m_buffer->dmabuf(); attrs.success) {
-        m_bufferDMA = true;
-
-        if (attrs.format != m_dmabufFormat) {
-            m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
-            PROTO::toplevelExport->destroyResource(this);
-            return;
-        }
-    } else if (auto attrs = PBUFFER->m_buffer->shm(); attrs.success) {
-        if (attrs.format != m_shmFormat) {
-            m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
-            PROTO::toplevelExport->destroyResource(this);
-            return;
-        } else if (attrs.stride != m_shmStride) {
-            m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer stride");
-            PROTO::toplevelExport->destroyResource(this);
-            return;
-        }
-    } else {
-        m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer type");
-        PROTO::toplevelExport->destroyResource(this);
+    const auto PBUFFERRES = CWLBufferResource::fromResource(buffer);
+    if UNLIKELY (!PBUFFERRES || !PBUFFERRES->m_buffer) {
+        LOGM(Log::ERR, "Invalid buffer in {:x}", (uintptr_t)this);
+        m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer");
+        m_resource->sendFailed();
         return;
     }
 
-    m_buffer = CHLBufferReference(PBUFFER->m_buffer.lock());
-
-    m_ignoreDamage = ignoreDamage;
-
-    if (ignoreDamage && validMapped(m_window))
-        share();
-    else
-        PROTO::toplevelExport->m_framesAwaitingWrite.emplace_back(m_self);
-}
+    const auto& PBUFFER = PBUFFERRES->m_buffer.lock();
 
-void CToplevelExportFrame::share() {
-    if (!m_buffer || !validMapped(m_window))
-        return;
+    if (ignoreDamage)
+        g_pHyprRenderer->damageMonitor(m_session->monitor());
 
-    if (m_bufferDMA) {
-        if (!copyDmabuf(Time::steadyNow())) {
-            m_resource->sendFailed();
+    auto error = m_frame->share(PBUFFER, {}, [this, ignoreDamage, self = m_self](eScreenshareResult result) {
+        if (self.expired() || !good())
             return;
-        }
-    } else {
-        if (!copyShm(Time::steadyNow())) {
-            m_resource->sendFailed();
-            return;
-        }
-    }
-
-    m_resource->sendFlags(sc<hyprlandToplevelExportFrameV1Flags>(0));
-
-    if (!m_ignoreDamage)
-        m_resource->sendDamage(0, 0, m_box.width, m_box.height);
-
-    const auto [sec, nsec] = Time::secNsec(Time::steadyNow());
-
-    uint32_t tvSecHi = (sizeof(sec) > 4) ? sec >> 32 : 0;
-    uint32_t tvSecLo = sec & 0xFFFFFFFF;
-    m_resource->sendReady(tvSecHi, tvSecLo, nsec);
-}
-
-bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
-    const auto PERM               = g_pDynamicPermissionManager->clientPermissionMode(m_resource->client(), PERMISSION_TYPE_SCREENCOPY);
-    auto       shm                = m_buffer->shm();
-    auto [pixelData, fmt, bufLen] = m_buffer->beginDataPtr(0); // no need for end, cuz it's shm
-
-    // render the client
-    const auto PMONITOR = m_window->m_monitor.lock();
-    CRegion    fakeDamage{0, 0, PMONITOR->m_pixelSize.x * 10, PMONITOR->m_pixelSize.y * 10};
-
-    g_pHyprRenderer->makeEGLCurrent();
-
-    CFramebuffer outFB;
-    outFB.alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
-
-    auto overlayCursor = shouldOverlayCursor();
-
-    if (overlayCursor) {
-        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
-    }
-
-    if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &outFB))
-        return false;
-
-    g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0));
-
-    // render client at 0,0
-    if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
-        if (!m_window->m_ruleApplicator->noScreenShare().valueOrDefault()) {
-            g_pHyprRenderer->m_bBlockSurfaceFeedback = g_pHyprRenderer->shouldRenderWindow(m_window); // block the feedback to avoid spamming the surface if it's visible
-            g_pHyprRenderer->renderWindow(m_window, PMONITOR, now, false, RENDER_PASS_ALL, true, true);
-            g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
-        }
-        if (overlayCursor)
-            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value());
-    } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
-        CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
-        g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, {});
-    }
-
-    const auto PFORMAT = NFormatUtils::getPixelFormatFromDRM(shm.format);
-    if (!PFORMAT) {
-        g_pHyprRenderer->endRender();
-        return false;
-    }
-
-    g_pHyprOpenGL->m_renderData.blockScreenShader = true;
-    g_pHyprRenderer->endRender();
-
-    g_pHyprRenderer->makeEGLCurrent();
-    g_pHyprOpenGL->m_renderData.pMonitor = PMONITOR;
-    outFB.bind();
-
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, outFB.getFBID());
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
-
-    auto origin = Vector2D(0, 0);
-    switch (PMONITOR->m_transform) {
-        case WL_OUTPUT_TRANSFORM_FLIPPED_180:
-        case WL_OUTPUT_TRANSFORM_90: {
-            origin.y = PMONITOR->m_pixelSize.y - m_box.height;
-            break;
-        }
-        case WL_OUTPUT_TRANSFORM_FLIPPED_270:
-        case WL_OUTPUT_TRANSFORM_180: {
-            origin.x = PMONITOR->m_pixelSize.x - m_box.width;
-            origin.y = PMONITOR->m_pixelSize.y - m_box.height;
-            break;
-        }
-        case WL_OUTPUT_TRANSFORM_FLIPPED:
-        case WL_OUTPUT_TRANSFORM_270: {
-            origin.x = PMONITOR->m_pixelSize.x - m_box.width;
-            break;
-        }
-        default: break;
-    }
-
-    int glFormat = PFORMAT->glFormat;
-
-    if (glFormat == GL_RGBA)
-        glFormat = GL_BGRA_EXT;
-
-    if (glFormat != GL_BGRA_EXT && glFormat != GL_RGB) {
-        if (PFORMAT->swizzle.has_value()) {
-            std::array<GLint, 4> RGBA = SWIZZLE_RGBA;
-            std::array<GLint, 4> BGRA = SWIZZLE_BGRA;
-            if (PFORMAT->swizzle == RGBA)
-                glFormat = GL_RGBA;
-            else if (PFORMAT->swizzle == BGRA)
-                glFormat = GL_BGRA_EXT;
-            else {
-                LOGM(Log::ERR, "Copied frame via shm might be broken or color flipped");
-                glFormat = GL_RGBA;
+        switch (result) {
+            case RESULT_COPIED: {
+                m_resource->sendFlags(sc<hyprlandToplevelExportFrameV1Flags>(0));
+                if (!ignoreDamage)
+                    m_frame->damage().forEachRect([&](const auto& rect) { m_resource->sendDamage(rect.x1, rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1); });
+
+                const auto [sec, nsec] = Time::secNsec(m_timestamp);
+                uint32_t tvSecHi       = (sizeof(sec) > 4) ? sec >> 32 : 0;
+                uint32_t tvSecLo       = sec & 0xFFFFFFFF;
+                m_resource->sendReady(tvSecHi, tvSecLo, nsec);
+                break;
             }
+            case RESULT_NOT_COPIED:
+                LOGM(Log::ERR, "Frame share failed in {:x}", (uintptr_t)this);
+                m_resource->sendFailed();
+                break;
+            case RESULT_TIMESTAMP: m_timestamp = Time::steadyNow(); break;
         }
-    }
-
-    glReadPixels(origin.x, origin.y, m_box.width, m_box.height, glFormat, PFORMAT->glType, pixelData);
-
-    if (overlayCursor) {
-        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
-    }
-
-    outFB.unbind();
-    glPixelStorei(GL_PACK_ALIGNMENT, 4);
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-
-    return true;
-}
-
-bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
-    const auto PERM     = g_pDynamicPermissionManager->clientPermissionMode(m_resource->client(), PERMISSION_TYPE_SCREENCOPY);
-    const auto PMONITOR = m_window->m_monitor.lock();
-
-    CRegion    fakeDamage{0, 0, INT16_MAX, INT16_MAX};
-
-    auto       overlayCursor = shouldOverlayCursor();
-
-    if (overlayCursor) {
-        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
-    }
-
-    if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_TO_BUFFER, m_buffer.m_buffer))
-        return false;
-
-    g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0));
-    if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
-        if (!m_window->m_ruleApplicator->noScreenShare().valueOrDefault()) {
-            g_pHyprRenderer->m_bBlockSurfaceFeedback = g_pHyprRenderer->shouldRenderWindow(m_window); // block the feedback to avoid spamming the surface if it's visible
-            g_pHyprRenderer->renderWindow(m_window, PMONITOR, now, false, RENDER_PASS_ALL, true, true);
-            g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
-        }
-
-        if (overlayCursor)
-            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value());
-    } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
-        CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
-        g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, {});
-    }
-
-    g_pHyprOpenGL->m_renderData.blockScreenShader = true;
-    g_pHyprRenderer->endRender();
+    });
 
-    if (overlayCursor) {
-        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
+    switch (error) {
+        case ERROR_NONE: m_buffer = CHLBufferReference(PBUFFER); break;
+        case ERROR_NO_BUFFER: m_resource->error(HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer"); break;
+        case ERROR_BUFFER_SIZE:
+        case ERROR_BUFFER_FORMAT: m_resource->sendFailed(); break;
+        case ERROR_UNKNOWN:
+        case ERROR_STOPPED: m_resource->sendFailed(); break;
     }
-
-    return true;
-}
-
-bool CToplevelExportFrame::shouldOverlayCursor() const {
-    if (!m_cursorOverlayRequested)
-        return false;
-
-    auto pointerSurfaceResource = g_pSeatManager->m_state.pointerFocus.lock();
-
-    if (!pointerSurfaceResource)
-        return false;
-
-    auto pointerSurface = Desktop::View::CWLSurface::fromResource(pointerSurfaceResource);
-
-    return pointerSurface && Desktop::View::CWindow::fromView(pointerSurface->view()) == m_window;
-}
-
-bool CToplevelExportFrame::good() {
-    return m_resource->resource();
 }
 
 CToplevelExportProtocol::CToplevelExportProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
-    static auto P1 = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any data) {
-        auto window = std::any_cast<PHLWINDOW>(data);
-
-        onWindowUnmap(window);
-    });
+    ;
 }
 
 void CToplevelExportProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
@@ -426,69 +174,10 @@ void CToplevelExportProtocol::bindManager(wl_client* client, void* data, uint32_
 }
 
 void CToplevelExportProtocol::destroyResource(CToplevelExportClient* client) {
-    std::erase_if(m_clients, [&](const auto& other) { return other.get() == client; });
     std::erase_if(m_frames, [&](const auto& other) { return other->m_client.get() == client; });
-    std::erase_if(m_framesAwaitingWrite, [&](const auto& other) { return !other || other->m_client.get() == client; });
+    std::erase_if(m_clients, [&](const auto& other) { return other.get() == client; });
 }
 
 void CToplevelExportProtocol::destroyResource(CToplevelExportFrame* frame) {
     std::erase_if(m_frames, [&](const auto& other) { return other.get() == frame; });
-    std::erase_if(m_framesAwaitingWrite, [&](const auto& other) { return !other || other.get() == frame; });
-}
-
-void CToplevelExportProtocol::onOutputCommit(PHLMONITOR pMonitor) {
-    if (m_framesAwaitingWrite.empty())
-        return; // nothing to share
-
-    std::vector<WP<CToplevelExportFrame>> framesToRemove;
-    // reserve number of elements to avoid reallocations
-    framesToRemove.reserve(m_framesAwaitingWrite.size());
-
-    // share frame if correct output
-    for (auto const& f : m_framesAwaitingWrite) {
-        if (!f)
-            continue;
-
-        // check permissions
-        const auto PERM = g_pDynamicPermissionManager->clientPermissionMode(f->m_resource->client(), PERMISSION_TYPE_SCREENCOPY);
-
-        if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING)
-            continue; // pending an answer, don't do anything yet.
-
-        if (!validMapped(f->m_window)) {
-            framesToRemove.emplace_back(f);
-            continue;
-        }
-
-        if (!f->m_window)
-            continue;
-
-        const auto PWINDOW = f->m_window;
-
-        if (pMonitor != PWINDOW->m_monitor.lock())
-            continue;
-
-        CBox geometry = {PWINDOW->m_realPosition->value().x, PWINDOW->m_realPosition->value().y, PWINDOW->m_realSize->value().x, PWINDOW->m_realSize->value().y};
-
-        if (geometry.intersection({pMonitor->m_position, pMonitor->m_size}).empty())
-            continue;
-
-        f->share();
-
-        f->m_client->m_lastFrame.reset();
-        ++f->m_client->m_frameCounter;
-
-        framesToRemove.push_back(f);
-    }
-
-    for (auto const& f : framesToRemove) {
-        std::erase(m_framesAwaitingWrite, f);
-    }
-}
-
-void CToplevelExportProtocol::onWindowUnmap(PHLWINDOW pWindow) {
-    for (auto const& f : m_frames) {
-        if (f->m_window == pWindow)
-            f->m_window.reset();
-    }
 }