cry/Hyprland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

protocols: refactor class member vars (types) (#10261)

Browse source
This commit is contained in:
davc0n 2025-05-03 18:54:50 +02:00 • committed by GitHub
parent 3465efcdc1
commit 46ac115bd1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
21 changed files with 147 additions and 147 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/protocols/types/Buffer.cpp
View file

@ -1,104 +1,104 @@
#include "Buffer.hpp"
IHLBuffer::~IHLBuffer() {
if (locked() && resource)
if (locked() && m_resource)
sendRelease();
}
void IHLBuffer::sendRelease() {
resource->sendRelease();
syncReleasers.clear();
m_resource->sendRelease();
m_syncReleasers.clear();
}
void IHLBuffer::lock() {
nLocks++;
m_locks++;
}
void IHLBuffer::unlock() {
nLocks--;
m_locks--;
ASSERT(nLocks >= 0);
ASSERT(m_locks >= 0);
if (nLocks == 0)
if (m_locks == 0)
sendRelease();
}
bool IHLBuffer::locked() {
return nLocks > 0;
return m_locks > 0;
}
void IHLBuffer::onBackendRelease(const std::function<void()>& fn) {
if (hlEvents.backendRelease) {
hlEvents.backendRelease->emit(nullptr);
if (m_hlEvents.backendRelease) {
m_hlEvents.backendRelease->emit(nullptr);
Debug::log(LOG, "backendRelease emitted early");
}
hlEvents.backendRelease = events.backendRelease.registerListener([this, fn](std::any) {
m_hlEvents.backendRelease = events.backendRelease.registerListener([this, fn](std::any) {
fn();
hlEvents.backendRelease.reset();
m_hlEvents.backendRelease.reset();
});
}
void IHLBuffer::addReleasePoint(CDRMSyncPointState& point) {
ASSERT(locked());
if (point)
syncReleasers.emplace_back(point.createSyncRelease());
m_syncReleasers.emplace_back(point.createSyncRelease());
}
CHLBufferReference::CHLBufferReference() : buffer(nullptr) {
CHLBufferReference::CHLBufferReference() : m_buffer(nullptr) {
;
}
CHLBufferReference::CHLBufferReference(const CHLBufferReference& other) : buffer(other.buffer) {
if (buffer)
buffer->lock();
CHLBufferReference::CHLBufferReference(const CHLBufferReference& other) : m_buffer(other.m_buffer) {
if (m_buffer)
m_buffer->lock();
}
CHLBufferReference::CHLBufferReference(SP<IHLBuffer> buffer_) : buffer(buffer_) {
if (buffer)
buffer->lock();
CHLBufferReference::CHLBufferReference(SP<IHLBuffer> buffer_) : m_buffer(buffer_) {
if (m_buffer)
m_buffer->lock();
}
CHLBufferReference::~CHLBufferReference() {
if (buffer)
buffer->unlock();
if (m_buffer)
m_buffer->unlock();
}
CHLBufferReference& CHLBufferReference::operator=(const CHLBufferReference& other) {
if (other.buffer)
other.buffer->lock();
if (buffer)
buffer->unlock();
buffer = other.buffer;
if (other.m_buffer)
other.m_buffer->lock();
if (m_buffer)
m_buffer->unlock();
m_buffer = other.m_buffer;
return *this;
}
bool CHLBufferReference::operator==(const CHLBufferReference& other) const {
return buffer == other.buffer;
return m_buffer == other.m_buffer;
}
bool CHLBufferReference::operator==(const SP<IHLBuffer>& other) const {
return buffer == other;
return m_buffer == other;
}
bool CHLBufferReference::operator==(const SP<Aquamarine::IBuffer>& other) const {
return buffer == other;
return m_buffer == other;
}
SP<IHLBuffer> CHLBufferReference::operator->() const {
return buffer;
return m_buffer;
}
CHLBufferReference::operator bool() const {
return buffer;
return m_buffer;
}
void CHLBufferReference::drop() {
if (!buffer)
if (!m_buffer)
return;
buffer->nLocks--;
ASSERT(buffer->nLocks >= 0);
m_buffer->m_locks--;
ASSERT(m_buffer->m_locks >= 0);
buffer = nullptr;
m_buffer = nullptr;
}

14
src/protocols/types/Buffer.hpp
View file

@ -26,18 +26,18 @@ class IHLBuffer : public Aquamarine::IBuffer {
void onBackendRelease(const std::function<void()>& fn);
void addReleasePoint(CDRMSyncPointState& point);
SP<CTexture> texture;
bool opaque = false;
SP<CWLBufferResource> resource;
std::vector<UP<CSyncReleaser>> syncReleasers;
SP<CTexture> m_texture;
bool m_opaque = false;
SP<CWLBufferResource> m_resource;
std::vector<UP<CSyncReleaser>> m_syncReleasers;
struct {
CHyprSignalListener backendRelease;
CHyprSignalListener backendRelease2; // for explicit ds
} hlEvents;
} m_hlEvents;
private:
int nLocks = 0;
int m_locks = 0;
friend class CHLBufferReference;
};
@ -60,5 +60,5 @@ class CHLBufferReference {
// unlock and drop the buffer without sending release
void drop();
SP<IHLBuffer> buffer;
SP<IHLBuffer> m_buffer;
};

46
src/protocols/types/DMABuffer.cpp
View file

@ -12,40 +12,40 @@
using namespace Hyprutils::OS;
CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs const& attrs_) : attrs(attrs_) {
CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs const& attrs_) : m_attrs(attrs_) {
g_pHyprRenderer->makeEGLCurrent();
listeners.resourceDestroy = events.destroy.registerListener([this](std::any d) {
m_listeners.resourceDestroy = events.destroy.registerListener([this](std::any d) {
closeFDs();
listeners.resourceDestroy.reset();
m_listeners.resourceDestroy.reset();
});
size = attrs.size;
resource = CWLBufferResource::create(makeShared<CWlBuffer>(client, 1, id));
size = m_attrs.size;
m_resource = CWLBufferResource::create(makeShared<CWlBuffer>(client, 1, id));
auto eglImage = g_pHyprOpenGL->createEGLImage(attrs);
auto eglImage = g_pHyprOpenGL->createEGLImage(m_attrs);
if UNLIKELY (!eglImage) {
Debug::log(ERR, "CDMABuffer: failed to import EGLImage, retrying as implicit");
attrs.modifier = DRM_FORMAT_MOD_INVALID;
eglImage = g_pHyprOpenGL->createEGLImage(attrs);
m_attrs.modifier = DRM_FORMAT_MOD_INVALID;
eglImage = g_pHyprOpenGL->createEGLImage(m_attrs);
if UNLIKELY (!eglImage) {
Debug::log(ERR, "CDMABuffer: failed to import EGLImage");
return;
}
}
texture = makeShared<CTexture>(attrs, eglImage); // texture takes ownership of the eglImage
opaque = NFormatUtils::isFormatOpaque(attrs.format);
success = texture->m_iTexID;
m_texture = makeShared<CTexture>(m_attrs, eglImage); // texture takes ownership of the eglImage
m_opaque = NFormatUtils::isFormatOpaque(m_attrs.format);
m_success = m_texture->m_iTexID;
if UNLIKELY (!success)
if UNLIKELY (!m_success)
Debug::log(ERR, "Failed to create a dmabuf: texture is null");
}
CDMABuffer::~CDMABuffer() {
if (resource)
resource->sendRelease();
if (m_resource)
m_resource->sendRelease();
closeFDs();
}
@ -67,7 +67,7 @@ bool CDMABuffer::isSynchronous() {
}
Aquamarine::SDMABUFAttrs CDMABuffer::dmabuf() {
return attrs;
return m_attrs;
}
std::tuple<uint8_t*, uint32_t, size_t> CDMABuffer::beginDataPtr(uint32_t flags) {
@ -80,17 +80,17 @@ void CDMABuffer::endDataPtr() {
}
bool CDMABuffer::good() {
return success;
return m_success;
}
void CDMABuffer::closeFDs() {
for (int i = 0; i < attrs.planes; ++i) {
if (attrs.fds[i] == -1)
for (int i = 0; i < m_attrs.planes; ++i) {
if (m_attrs.fds[i] == -1)
continue;
close(attrs.fds[i]);
attrs.fds[i] = -1;
close(m_attrs.fds[i]);
m_attrs.fds[i] = -1;
}
attrs.planes = 0;
m_attrs.planes = 0;
}
static int doIoctl(int fd, unsigned long request, void* arg) {
@ -111,8 +111,8 @@ CFileDescriptor CDMABuffer::exportSyncFile() {
#if !defined(__linux__)
return {};
#else
std::vector<CFileDescriptor> syncFds(attrs.fds.size());
for (const auto& fd : attrs.fds) {
std::vector<CFileDescriptor> syncFds(m_attrs.fds.size());
for (const auto& fd : m_attrs.fds) {
if (fd == -1)
continue;

6
src/protocols/types/DMABuffer.hpp
View file

@ -19,12 +19,12 @@ class CDMABuffer : public IHLBuffer {
void closeFDs();
Hyprutils::OS::CFileDescriptor exportSyncFile();
bool success = false;
bool m_success = false;
private:
Aquamarine::SDMABUFAttrs attrs;
Aquamarine::SDMABUFAttrs m_attrs;
struct {
CHyprSignalListener resourceDestroy;
} listeners;
} m_listeners;
};

4
src/protocols/types/DataDevice.cpp
View file

@ -9,11 +9,11 @@ bool IDataSource::dndDone() {
}
bool IDataSource::used() {
return wasUsed;
return m_wasUsed;
}
void IDataSource::markUsed() {
wasUsed = true;
m_wasUsed = true;
}
eDataSourceType IDataSource::type() {

4
src/protocols/types/DataDevice.hpp
View file

@ -42,10 +42,10 @@ class IDataSource {
struct {
CSignal destroy;
} events;
} m_events;
private:
bool wasUsed = false;
bool m_wasUsed = false;
};
class IDataOffer {

28
src/protocols/types/WLBuffer.cpp
View file

@ -5,43 +5,43 @@
#include "../../helpers/sync/SyncTimeline.hpp"
#include <xf86drm.h>
CWLBufferResource::CWLBufferResource(WP<CWlBuffer> resource_) : resource(resource_.lock()) {
CWLBufferResource::CWLBufferResource(WP<CWlBuffer> resource_) : m_resource(resource_.lock()) {
if UNLIKELY (!good())
return;
resource->setOnDestroy([this](CWlBuffer* r) {
if (buffer.expired())
m_resource->setOnDestroy([this](CWlBuffer* r) {
if (m_buffer.expired())
return;
buffer->events.destroy.emit();
m_buffer->events.destroy.emit();
});
resource->setDestroy([this](CWlBuffer* r) {
if (buffer.expired())
m_resource->setDestroy([this](CWlBuffer* r) {
if (m_buffer.expired())
return;
buffer->events.destroy.emit();
m_buffer->events.destroy.emit();
});
resource->setData(this);
m_resource->setData(this);
}
bool CWLBufferResource::good() {
return resource->resource();
return m_resource->resource();
}
void CWLBufferResource::sendRelease() {
resource->sendRelease();
m_resource->sendRelease();
}
wl_resource* CWLBufferResource::getResource() {
return resource->resource();
return m_resource->resource();
}
SP<CWLBufferResource> CWLBufferResource::fromResource(wl_resource* res) {
auto data = (CWLBufferResource*)(((CWlBuffer*)wl_resource_get_user_data(res))->data());
return data ? data->self.lock() : nullptr;
return data ? data->m_self.lock() : nullptr;
}
SP<CWLBufferResource> CWLBufferResource::create(WP<CWlBuffer> resource) {
auto p = SP<CWLBufferResource>(new CWLBufferResource(resource));
p->self = p;
auto p = SP<CWLBufferResource>(new CWLBufferResource(resource));
p->m_self = p;
return p;
}

6
src/protocols/types/WLBuffer.hpp
View file

@ -18,14 +18,14 @@ class CWLBufferResource {
void sendRelease();
wl_resource* getResource();
WP<IHLBuffer> buffer;
WP<IHLBuffer> m_buffer;
WP<CWLBufferResource> self;
WP<CWLBufferResource> m_self;
private:
CWLBufferResource(WP<CWlBuffer> resource_);
SP<CWlBuffer> resource;
SP<CWlBuffer> m_resource;
friend class IHLBuffer;
};