remove syncReleaser and properly release buffers in renderer

Author: ikalco

src/helpers/Monitor.cpp

@@ -3,7 +3,6 @@
 #include "../macros.hpp"
 #include "math/Math.hpp"
 #include "../protocols/ColorManagement.hpp"
-#include "sync/SyncReleaser.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../protocols/GammaControl.hpp"

src/helpers/Monitor.hpp

@@ -140,8 +140,7 @@ class CMonitor {
 
     // explicit sync
     SP<CSyncTimeline>              inTimeline;
-    Hyprutils::OS::CFileDescriptor inFence;
-    SP<CEGLSync>                   eglSync;
+    Hyprutils::OS::CFileDescriptor inFence; // TODO: remove when aq uses CFileDescriptor
     uint64_t                       inTimelinePoint = 0;
 
     PHLMONITORREF                  self;

src/helpers/sync/SyncReleaser.cpp

@@ -19,27 +19,23 @@ WP<CSyncTimeline> CDRMSyncPointState::timeline() {
     return m_timeline;
 }
 
-UP<CSyncReleaser> CDRMSyncPointState::createSyncRelease() {
-    if (m_releaseTaken)
-        Debug::log(ERR, "CDRMSyncPointState: creating a sync releaser on an already created SyncRelease");
-
-    m_releaseTaken = true;
-    return makeUnique<CSyncReleaser>(m_timeline, m_point);
-}
-
 bool CDRMSyncPointState::addWaiter(const std::function<void()>& waiter) {
-    m_acquireCommitted = true;
     return m_timeline->addWaiter(waiter, m_point, 0u);
 }
 
-bool CDRMSyncPointState::comitted() {
-    return m_acquireCommitted;
+bool CDRMSyncPointState::syncImported() {
+    return m_imported;
 }
 
-CFileDescriptor CDRMSyncPointState::exportAsFD() {
+CFileDescriptor CDRMSyncPointState::exportSyncFD() {
     return m_timeline->exportAsSyncFileFD(m_point);
 }
 
+bool CDRMSyncPointState::importSyncFD(CFileDescriptor& fd) {
+    m_imported = true;
+    return m_timeline->importFromSyncFileFD(m_point, fd);
+}
+
 void CDRMSyncPointState::signal() {
     m_timeline->signal(m_point);
 }
@@ -105,10 +101,8 @@ CDRMSyncobjSurfaceResource::CDRMSyncobjSurfaceResource(UP<CWpLinuxDrmSyncobjSurf
         surface->pending.acquire         = pendingAcquire;
         pendingAcquire                   = {};
 
-        surface->pending.buffer.release = pendingRelease;
-        pendingRelease                  = {};
-
-        surface->pending.buffer->syncReleaser = surface->pending.buffer.release.createSyncRelease();
+        surface->pending.buffer->addReleasePoint(pendingRelease);
+        pendingRelease = {};
     });
 }
 

src/helpers/sync/SyncReleaser.hpp

@@ -2,7 +2,6 @@
 
 #include <vector>
 #include "WaylandProtocol.hpp"
-#include "../helpers/sync/SyncReleaser.hpp"
 #include "linux-drm-syncobj-v1.hpp"
 #include "../helpers/signal/Signal.hpp"
 #include <hyprutils/os/FileDescriptor.hpp>
@@ -17,23 +16,22 @@ class CDRMSyncPointState {
     CDRMSyncPointState(SP<CSyncTimeline> timeline_, uint64_t point_);
     ~CDRMSyncPointState() = default;
 
-    const uint64_t&                                  point();
-    WP<CSyncTimeline>                                timeline();
-    Hyprutils::Memory::CUniquePointer<CSyncReleaser> createSyncRelease();
-    bool                                             addWaiter(const std::function<void()>& waiter);
-    bool                                             comitted();
-    Hyprutils::OS::CFileDescriptor                   exportAsFD();
-    void                                             signal();
+    const uint64_t&                point();
+    WP<CSyncTimeline>              timeline();
+    bool                           addWaiter(const std::function<void()>& waiter);
+    bool                           syncImported();
+    Hyprutils::OS::CFileDescriptor exportSyncFD();
+    bool                           importSyncFD(Hyprutils::OS::CFileDescriptor& fd);
+    void                           signal();
 
     operator bool() const {
         return m_timeline;
     }
 
   private:
-    SP<CSyncTimeline> m_timeline         = {};
-    uint64_t          m_point            = 0;
-    bool              m_acquireCommitted = false;
-    bool              m_releaseTaken     = false;
+    SP<CSyncTimeline> m_timeline = {};
+    uint64_t          m_point    = 0;
+    bool              m_imported = false;
 };
 
 class CDRMSyncobjSurfaceResource {

src/protocols/DRMSyncobj.cpp

@@ -7,7 +7,6 @@
 #include "Subcompositor.hpp"
 #include "../Viewporter.hpp"
 #include "../../helpers/Monitor.hpp"
-#include "../../helpers/sync/SyncReleaser.hpp"
 #include "../PresentationTime.hpp"
 #include "../DRMSyncobj.hpp"
 #include "../types/DMABuffer.hpp"
@@ -520,8 +519,7 @@ void CWLSurfaceResource::commitState(SSurfaceState& state) {
             nullptr);
     }
 
-    // release the buffer if it's synchronous (SHM) as update() has done everything thats needed
-    // so we can let the app know we're done.
+    // release the buffer if it's synchronous (SHM) as updateSynchronousTexture() has copied the buffer data to a GPU tex
     // if it doesn't have a role, we can't release it yet, in case it gets turned into a cursor.
     if (current.buffer && current.buffer->isSynchronous() && role->role() != SURFACE_ROLE_UNASSIGNED)
         dropCurrentBuffer();
@@ -574,12 +572,6 @@ void CWLSurfaceResource::presentFeedback(timespec* when, PHLMONITOR pMonitor, bo
     else
         FEEDBACK->presented();
     PROTO::presentation->queueData(FEEDBACK);
-
-    if (!pMonitor || !pMonitor->inTimeline || !syncobj)
-        return;
-
-    // attach explicit sync
-    g_pHyprRenderer->explicitPresented.emplace_back(self.lock());
 }
 
 CWLCompositorResource::CWLCompositorResource(SP<CWlCompositor> resource_) : resource(resource_) {

src/protocols/DRMSyncobj.hpp

@@ -1,4 +1,5 @@
 #include "Buffer.hpp"
+#include "../DRMSyncobj.hpp"
 
 IHLBuffer::~IHLBuffer() {
     if (locked() && resource)
@@ -7,6 +8,11 @@ IHLBuffer::~IHLBuffer() {
 
 void IHLBuffer::sendRelease() {
     resource->sendRelease();
+    for (auto& point : releasePoints) {
+        if (point && !point.syncImported())
+            point.signal();
+    }
+    releasePoints.clear();
 }
 
 void IHLBuffer::lock() {
@@ -18,10 +24,8 @@ void IHLBuffer::unlock() {
 
     ASSERT(nLocks >= 0);
 
-    if (nLocks == 0) {
+    if (nLocks == 0)
         sendRelease();
-        syncReleaser.reset();
-    }
 }
 
 bool IHLBuffer::locked() {
@@ -40,11 +44,17 @@ void IHLBuffer::onBackendRelease(const std::function<void()>& fn) {
     });
 }
 
+void IHLBuffer::addReleasePoint(const CDRMSyncPointState& point) {
+    ASSERT(locked());
+    if (point)
+        releasePoints.emplace_back(point);
+}
+
 CHLBufferReference::CHLBufferReference() : buffer(nullptr) {
     ;
 }
 
-CHLBufferReference::CHLBufferReference(const CHLBufferReference& other) : release(other.release), buffer(other.buffer) {
+CHLBufferReference::CHLBufferReference(const CHLBufferReference& other) : buffer(other.buffer) {
     if (buffer)
         buffer->lock();
 }
@@ -64,8 +74,7 @@ CHLBufferReference& CHLBufferReference::operator=(const CHLBufferReference& othe
         other.buffer->lock();
     if (buffer)
         buffer->unlock();
-    buffer  = other.buffer;
-    release = other.release;
+    buffer = other.buffer;
     return *this;
 }
 

src/protocols/core/Compositor.cpp

@@ -24,11 +24,12 @@ class IHLBuffer : public Aquamarine::IBuffer {
     virtual bool                          locked();
 
     void                                  onBackendRelease(const std::function<void()>& fn);
+    void                                  addReleasePoint(const CDRMSyncPointState& point);
 
     SP<CTexture>                          texture;
     bool                                  opaque = false;
     SP<CWLBufferResource>                 resource;
-    UP<CSyncReleaser>                     syncReleaser;
+    std::vector<CDRMSyncPointState>       releasePoints;
 
     struct {
         CHyprSignalListener backendRelease;
@@ -57,8 +58,7 @@ class CHLBufferReference {
     operator bool() const;
 
     // unlock and drop the buffer without sending release
-    void               drop();
+    void          drop();
 
-    CDRMSyncPointState release;
-    SP<IHLBuffer>      buffer;
+    SP<IHLBuffer> buffer;
 };