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

core/compositor: Correctly track SHM buffer damage (#9678)

Browse Source
This commit is contained in:
Lee Bousfield 2025-03-22 11:13:44 -05:00 committed by GitHub
parent 4600043a49
commit 6384f4acf4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 103 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/desktop/WLSurface.cpp
View File

@ -98,7 +98,7 @@ CRegion CWLSurface::computeDamage() const {
if (!m_pResource->current.texture)
return {};
CRegion damage = m_pResource->accumulateCurrentBufferDamage();
CRegion damage = m_pResource->current.accumulateBufferDamage();
damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y);
const auto BUFSIZE = m_pResource->current.bufferSize;

2
src/events/Windows.cpp
View File

@ -880,7 +880,7 @@ void Events::listener_commitWindow(void* owner, void* data) {
// tearing: if solitary, redraw it. This still might be a single surface window
if (PMONITOR && PMONITOR->solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear && PWINDOW->m_pWLSurface->resource()->current.texture) {
CRegion damageBox{PWINDOW->m_pWLSurface->resource()->accumulateCurrentBufferDamage()};
CRegion damageBox{PWINDOW->m_pWLSurface->resource()->current.accumulateBufferDamage()};
if (!damageBox.empty()) {
if (PMONITOR->tearingState.busy) {

2
src/helpers/Monitor.cpp
View File

@ -1400,7 +1400,7 @@ bool CMonitor::attemptDirectScanout() {
clock_gettime(CLOCK_MONOTONIC, &now);
PSURFACE->presentFeedback(&now, self.lock());
output->state->addDamage(PSURFACE->accumulateCurrentBufferDamage());
output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
output->state->resetExplicitFences();
auto cleanup = CScopeGuard([this]() { output->state->resetExplicitFences(); });

2
src/protocols/DRMSyncobj.cpp
View File

@ -137,7 +137,7 @@ CDRMSyncobjSurfaceResource::~CDRMSyncobjSurfaceResource() {
}
bool CDRMSyncobjSurfaceResource::protocolError() {
if (!surface->pending.texture) {
if (!surface->pending.buffer) {
resource->error(WP_LINUX_DRM_SYNCOBJ_SURFACE_V1_ERROR_NO_BUFFER, "Missing buffer");
surface->pending.rejected = true;
return true;

2
src/protocols/Viewporter.cpp
View File

@ -52,7 +52,7 @@ CViewportResource::CViewportResource(SP<CWpViewport> resource_, SP<CWLSurfaceRes
});
listeners.surfacePrecommit = surface->events.precommit.registerListener([this](std::any d) {
if (!surface || !surface->pending.texture)
if (!surface || !surface->pending.buffer)
return;
if (surface->pending.viewport.hasSource) {

2
src/protocols/XDGShell.cpp
View File

@ -387,7 +387,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP<CXdgSurface> resource_, SP<CXDGWMBas
if (toplevel)
toplevel->current = toplevel->pending;
if UNLIKELY (initialCommit && surface->pending.texture) {
if UNLIKELY (initialCommit && surface->pending.buffer) {
resource->error(-1, "Buffer attached before initial commit");
return;
}

53
src/protocols/core/Compositor.cpp
View File

@ -12,6 +12,7 @@
#include "../DRMSyncobj.hpp"
#include "../../render/Renderer.hpp"
#include "config/ConfigValue.hpp"
#include "render/Texture.hpp"
#include <cstring>
class CDefaultSurfaceRole : public ISurfaceRole {
@ -91,10 +92,10 @@ CWLSurfaceResource::CWLSurfaceResource(SP<CWlSurface> resource_) : resource(reso
});
resource->setCommit([this](CWlSurface* r) {
if (pending.texture)
if (pending.buffer)
pending.bufferDamage.intersect(CBox{{}, pending.bufferSize});
if (!pending.texture)
if (!pending.buffer)
pending.size = {};
else if (pending.viewport.hasDestination)
pending.size = pending.viewport.destination;
@ -399,36 +400,8 @@ CBox CWLSurfaceResource::extends() {
return full.getExtents();
}
Vector2D CWLSurfaceResource::sourceSize() {
if UNLIKELY (!current.texture)
return {};
if UNLIKELY (current.viewport.hasSource)
return current.viewport.source.size();
Vector2D trc = current.transform % 2 == 1 ? Vector2D{current.bufferSize.y, current.bufferSize.x} : current.bufferSize;
return trc / current.scale;
}
CRegion CWLSurfaceResource::accumulateCurrentBufferDamage() {
if UNLIKELY (!current.texture)
return {};
CRegion surfaceDamage = current.damage;
if (current.viewport.hasDestination) {
Vector2D scale = sourceSize() / current.viewport.destination;
surfaceDamage.scale(scale);
}
if (current.viewport.hasSource)
surfaceDamage.translate(current.viewport.source.pos());
Vector2D trc = current.transform % 2 == 1 ? Vector2D{current.bufferSize.y, current.bufferSize.x} : current.bufferSize;
return surfaceDamage.scale(current.scale).transform(wlTransformToHyprutils(invertTransform(current.transform)), trc.x, trc.y).add(current.bufferDamage);
}
void CWLSurfaceResource::commitPendingState(SSurfaceState& state) {
auto lastTexture = current.texture;
if (state.newBuffer) {
state.newBuffer = false;
current = state;
@ -437,20 +410,19 @@ void CWLSurfaceResource::commitPendingState(SSurfaceState& state) {
state.buffer.reset();
}
if (current.texture)
current.texture->m_eTransform = wlTransformToHyprutils(current.transform);
if (current.buffer) {
const auto DAMAGE = accumulateCurrentBufferDamage();
current.buffer->buffer->update(DAMAGE);
if (current.buffer->buffer->isSynchronous())
current.updateSynchronousTexture(lastTexture);
// if the surface is a cursor, update the shm buffer
// TODO: don't update the entire texture
if (role->role() == SURFACE_ROLE_CURSOR && !DAMAGE.empty())
updateCursorShm(DAMAGE);
if (role->role() == SURFACE_ROLE_CURSOR)
updateCursorShm(current.accumulateBufferDamage());
}
// TODO: we should _accumulate_ and not replace above if sync
if (current.texture)
current.texture->m_eTransform = wlTransformToHyprutils(current.transform);
if (role->role() == SURFACE_ROLE_SUBSURFACE) {
auto subsurface = ((CSubsurfaceRole*)role.get())->subsurface.lock();
if (subsurface->sync)
@ -478,6 +450,9 @@ void CWLSurfaceResource::commitPendingState(SSurfaceState& state) {
}
void CWLSurfaceResource::updateCursorShm(CRegion damage) {
if (damage.empty())
return;
auto buf = current.buffer ? current.buffer->buffer : SP<IHLBuffer>{};
if UNLIKELY (!buf)

3
src/protocols/core/Compositor.hpp
View File

@ -11,6 +11,7 @@
#include <vector>
#include <cstdint>
#include "../WaylandProtocol.hpp"
#include "render/Texture.hpp"
#include "wayland.hpp"
#include "../../helpers/signal/Signal.hpp"
#include "../../helpers/math/Math.hpp"
@ -75,7 +76,6 @@ class CWLSurfaceResource {
SP<CWlSurface> getResource();
CBox extends();
void resetRole();
Vector2D sourceSize();
struct {
CSignal precommit; // before commit
@ -102,7 +102,6 @@ class CWLSurfaceResource {
void breadthfirst(std::function<void(SP<CWLSurfaceResource>, const Vector2D&, void*)> fn, void* data);
SP<CWLSurfaceResource> findFirstPreorder(std::function<bool(SP<CWLSurfaceResource>)> fn);
CRegion accumulateCurrentBufferDamage();
void presentFeedback(timespec* when, PHLMONITOR pMonitor, bool discarded = false);
void commitPendingState(SSurfaceState& state);

11
src/protocols/core/Shm.cpp
View File

@ -22,19 +22,12 @@ CWLSHMBuffer::CWLSHMBuffer(SP<CWLSHMPoolResource> pool_, uint32_t id, int32_t of
offset = offset_;
opaque = NFormatUtils::isFormatOpaque(NFormatUtils::shmToDRM(fmt_));
texture = makeShared<CTexture>(NFormatUtils::shmToDRM(fmt), (uint8_t*)pool->data + offset, stride, size_);
resource = CWLBufferResource::create(makeShared<CWlBuffer>(pool_->resource->client(), 1, id));
listeners.bufferResourceDestroy = events.destroy.registerListener([this](std::any d) {
listeners.bufferResourceDestroy.reset();
PROTO::shm->destroyResource(this);
});
success = texture->m_iTexID;
if UNLIKELY (!success)
Debug::log(ERR, "Failed creating a shm texture: null texture id");
}
CWLSHMBuffer::~CWLSHMBuffer() {
@ -74,11 +67,11 @@ void CWLSHMBuffer::endDataPtr() {
}
bool CWLSHMBuffer::good() {
return success;
return true;
}
void CWLSHMBuffer::update(const CRegion& damage) {
texture->update(NFormatUtils::shmToDRM(fmt), (uint8_t*)pool->data + offset, stride, damage);
;
}
CSHMPool::CSHMPool(CFileDescriptor fd_, size_t size_) : fd(std::move(fd_)), size(size_), data(mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0)) {

2
src/protocols/core/Shm.hpp
View File

@ -50,8 +50,6 @@ class CWLSHMBuffer : public IHLBuffer {
SP<CSHMPool> pool;
private:
bool success = false;
struct {
CHyprSignalListener bufferResourceDestroy;
} listeners;

58
src/protocols/types/SurfaceState.cpp Normal file
View File

@ -0,0 +1,58 @@
#include "SurfaceState.hpp"
#include "helpers/Format.hpp"
#include "protocols/types/Buffer.hpp"
#include "render/Texture.hpp"
Vector2D SSurfaceState::sourceSize() {
if UNLIKELY (!texture)
return {};
if UNLIKELY (viewport.hasSource)
return viewport.source.size();
Vector2D trc = transform % 2 == 1 ? Vector2D{bufferSize.y, bufferSize.x} : bufferSize;
return trc / scale;
}
CRegion SSurfaceState::accumulateBufferDamage() {
if (damage.empty())
return bufferDamage;
CRegion surfaceDamage = damage;
if (viewport.hasDestination) {
Vector2D scale = sourceSize() / viewport.destination;
surfaceDamage.scale(scale);
}
if (viewport.hasSource)
surfaceDamage.translate(viewport.source.pos());
Vector2D trc = transform % 2 == 1 ? Vector2D{bufferSize.y, bufferSize.x} : bufferSize;
bufferDamage = surfaceDamage.scale(scale).transform(wlTransformToHyprutils(invertTransform(transform)), trc.x, trc.y).add(bufferDamage);
damage.clear();
return bufferDamage;
}
void SSurfaceState::updateSynchronousTexture(SP<CTexture> lastTexture) {
auto [dataPtr, fmt, size] = buffer->buffer->beginDataPtr(0);
if (dataPtr) {
auto drmFmt = NFormatUtils::shmToDRM(fmt);
auto stride = bufferSize.y ? size / bufferSize.y : 0;
if (lastTexture && lastTexture->m_isSynchronous && lastTexture->m_vSize == bufferSize) {
texture = lastTexture;
texture->update(drmFmt, dataPtr, stride, accumulateBufferDamage());
} else
texture = makeShared<CTexture>(drmFmt, dataPtr, stride, bufferSize);
}
buffer->buffer->endDataPtr();
}
void SSurfaceState::reset() {
damage.clear();
bufferDamage.clear();
transform = WL_OUTPUT_TRANSFORM_NORMAL;
scale = 1;
offset = {};
size = {};
}

18
src/protocols/types/SurfaceState.hpp
View File

@ -20,16 +20,12 @@ struct SSurfaceState {
Vector2D destination;
CBox source;
} viewport;
bool rejected = false;
bool newBuffer = false;
bool rejected = false;
bool newBuffer = false;
//
void reset() {
damage.clear();
bufferDamage.clear();
transform = WL_OUTPUT_TRANSFORM_NORMAL;
scale = 1;
offset = {};
size = {};
}
Vector2D sourceSize();
// Translates damage into bufferDamage, clearing damage and returning the updated bufferDamage
CRegion accumulateBufferDamage();
void updateSynchronousTexture(SP<CTexture> lastTexture);
void reset();
};

5
src/render/Texture.cpp
View File

@ -64,8 +64,9 @@ void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t strid
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format);
m_iType = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX;
m_vSize = size_;
m_iType = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX;
m_vSize = size_;
m_isSynchronous = true;
allocate();
GLCALL(glBindTexture(GL_TEXTURE_2D, m_iTexID));

17
src/render/Texture.hpp
View File

@ -35,14 +35,15 @@ class CTexture {
void update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const CRegion& damage);
const std::vector<uint8_t>& dataCopy();
eTextureType m_iType = TEXTURE_RGBA;
GLenum m_iTarget = GL_TEXTURE_2D;
GLuint m_iTexID = 0;
Vector2D m_vSize = {};
void* m_pEglImage = nullptr;
eTransform m_eTransform = HYPRUTILS_TRANSFORM_NORMAL;
bool m_bOpaque = false;
uint32_t m_iDrmFormat = 0; // for shm
eTextureType m_iType = TEXTURE_RGBA;
GLenum m_iTarget = GL_TEXTURE_2D;
GLuint m_iTexID = 0;
Vector2D m_vSize = {};
void* m_pEglImage = nullptr;
eTransform m_eTransform = HYPRUTILS_TRANSFORM_NORMAL;
bool m_bOpaque = false;
uint32_t m_iDrmFormat = 0; // for shm
bool m_isSynchronous = false;
private:
void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size);

6
src/xwayland/XSurface.cpp
View File

@ -62,12 +62,12 @@ void CXWaylandSurface::ensureListeners() {
});
listeners.commitSurface = surface->events.commit.registerListener([this](std::any d) {
if (surface->pending.texture && !mapped) {
if (surface->current.texture && !mapped) {
map();
return;
}
if (!surface->pending.texture && mapped) {
if (!surface->current.texture && mapped) {
unmap();
return;
}
@ -131,7 +131,7 @@ void CXWaylandSurface::considerMap() {
return;
}
if (surface->pending.texture) {
if (surface->current.texture) {
Debug::log(LOG, "XWayland surface: considerMap, sure, we have a buffer");
map();
return;