twin/hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-08-06 23:21:57 -07:00
Code Issues Packages Projects Releases Wiki Activity

render: properly release rendered buffers (#9807)

Browse Source 
* cleanup eglSync

* properly release buffers in renderer

* add renderingDoneCallback and use it in screencopy

* use static constructor for CEGLSync
This commit is contained in:
Ikalco
2025-04-30 11:35:25 -05:00
committed by GitHub
parent 5d005f11fa
commit 2ee5118d7a
14 changed files with 119 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/render/Renderer.cpp
View File

@@ -1,7 +1,6 @@
#include "Renderer.hpp"
#include "../Compositor.hpp"
#include "../helpers/math/Math.hpp"
#include "../helpers/sync/SyncReleaser.hpp"
#include <algorithm>
#include <aquamarine/output/Output.hpp>
#include <filesystem>
@@ -1571,25 +1570,6 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
}
}
auto explicitOptions = getExplicitSyncSettings(pMonitor->output);
if (!explicitOptions.explicitEnabled)
return ok;
Debug::log(TRACE, "Explicit: {} presented", explicitPresented.size());
if (!pMonitor->eglSync)
Debug::log(TRACE, "Explicit: can't add sync, monitor has no EGLSync");
else {
for (auto const& e : explicitPresented) {
if (!e->current.buffer || !e->current.buffer->syncReleaser)
continue;
e->current.buffer->syncReleaser->addReleaseSync(pMonitor->eglSync);
}
}
explicitPresented.clear();
return ok;
}
@@ -2275,7 +2255,7 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
return true;
}
void CHyprRenderer::endRender() {
void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback) {
const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor;
static auto PNVIDIAANTIFLICKER = CConfigValue<Hyprlang::INT>("opengl:nvidia_anti_flicker");
@@ -2296,42 +2276,48 @@ void CHyprRenderer::endRender() {
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = true;
}
// send all queued opengl commands so rendering starts happening immediately
glFlush();
if (m_eRenderMode == RENDER_MODE_FULL_FAKE)
return;
if (m_eRenderMode == RENDER_MODE_NORMAL)
PMONITOR->output->state->setBuffer(m_pCurrentBuffer);
auto explicitOptions = getExplicitSyncSettings(PMONITOR->output);
if (PMONITOR->inTimeline && explicitOptions.explicitEnabled) {
PMONITOR->eglSync = g_pHyprOpenGL->createEGLSync();
if (!PMONITOR->eglSync) {
Debug::log(ERR, "renderer: couldn't create an EGLSync for out in endRender");
return;
}
PMONITOR->inTimelinePoint++;
bool ok = PMONITOR->inTimeline->importFromSyncFileFD(PMONITOR->inTimelinePoint, PMONITOR->eglSync->fd());
if (!ok) {
Debug::log(ERR, "renderer: couldn't import from sync file fd in endRender");
return;
}
if (m_eRenderMode == RENDER_MODE_NORMAL && explicitOptions.explicitKMSEnabled) {
PMONITOR->inFence = CFileDescriptor{PMONITOR->inTimeline->exportAsSyncFileFD(PMONITOR->inTimelinePoint)};
if (!PMONITOR->inFence.isValid()) {
Debug::log(ERR, "renderer: couldn't export from sync timeline in endRender");
return;
UP<CEGLSync> eglSync = CEGLSync::create();
if (eglSync && eglSync->isValid()) {
for (auto const& buf : usedAsyncBuffers) {
for (const auto& releaser : buf->syncReleasers) {
releaser->addSyncFileFd(eglSync->fd());
}
}
// release buffer refs with release points now, since syncReleaser handles actual buffer release based on EGLSync
std::erase_if(usedAsyncBuffers, [](const auto& buf) { return !buf->syncReleasers.empty(); });
// release buffer refs without release points when EGLSync sync_file/fence is signalled
g_pEventLoopManager->doOnReadable(eglSync->fd().duplicate(), [renderingDoneCallback, prevbfs = std::move(usedAsyncBuffers)]() mutable {
prevbfs.clear();
if (renderingDoneCallback)
renderingDoneCallback();
});
usedAsyncBuffers.clear();
if (m_eRenderMode == RENDER_MODE_NORMAL) {
PMONITOR->inFence = eglSync->takeFd();
PMONITOR->output->state->setExplicitInFence(PMONITOR->inFence.get());
}
} else {
Debug::log(ERR, "renderer: couldn't use EGLSync for explicit gpu synchronization");
// nvidia doesn't have implicit sync, so we have to explicitly wait here
if (isNvidia() && *PNVIDIAANTIFLICKER)
glFinish();
else
glFlush();
usedAsyncBuffers.clear(); // release all buffer refs and hope implicit sync works
if (renderingDoneCallback)
renderingDoneCallback();
}
}