add a drm_dumb allocator

include/aquamarine/allocator/Allocator.hpp

@@ -16,6 +16,7 @@ namespace Aquamarine {
 
     enum eAllocatorType {
         AQ_ALLOCATOR_TYPE_GBM = 0,
+        AQ_ALLOCATOR_TYPE_DRM_DUMB,
     };
 
     class IAllocator {

include/aquamarine/allocator/DRMDumb.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "Allocator.hpp"
+
+namespace Aquamarine {
+    class CDRMDumbAllocator;
+    class CBackend;
+    class CSwapchain;
+
+    class CDRMDumbBuffer : public IBuffer {
+      public:
+        virtual ~CDRMDumbBuffer();
+
+        virtual eBufferCapability                      caps();
+        virtual eBufferType                            type();
+        virtual void                                   update(const Hyprutils::Math::CRegion& damage);
+        virtual bool                                   isSynchronous();
+        virtual bool                                   good();
+        virtual SSHMAttrs                              shm();
+        virtual std::tuple<uint8_t*, uint32_t, size_t> beginDataPtr(uint32_t flags);
+        virtual void                                   endDataPtr();
+        virtual uint32_t                               drmHandle();
+
+      private:
+        CDRMDumbBuffer(const SAllocatorBufferParams& params, Hyprutils::Memory::CWeakPointer<CDRMDumbAllocator> allocator_,
+                       Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain);
+
+        Hyprutils::Memory::CWeakPointer<CDRMDumbAllocator> allocator;
+
+        //
+        uint32_t                  drmID = 0;
+        Hyprutils::Math::Vector2D pixelSize;
+        uint32_t                  stride = 0, handle = 0;
+        uint64_t                  size = 0;
+        uint8_t*                  data = nullptr;
+
+        //
+        SSHMAttrs attrs{.success = false};
+
+        friend class CDRMDumbAllocator;
+    };
+
+    class CDRMDumbAllocator : public IAllocator {
+      public:
+        ~CDRMDumbAllocator();
+        static Hyprutils::Memory::CSharedPointer<CDRMDumbAllocator> create(int drmfd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_);
+
+        virtual Hyprutils::Memory::CSharedPointer<IBuffer>          acquire(const SAllocatorBufferParams& params, Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain_);
+        virtual Hyprutils::Memory::CSharedPointer<CBackend>         getBackend();
+        virtual int                                                 drmFD();
+        virtual eAllocatorType                                      type();
+
+        //
+        Hyprutils::Memory::CWeakPointer<CDRMDumbAllocator> self;
+
+      private:
+        CDRMDumbAllocator(int fd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_);
+
+        // a vector purely for tracking (debugging) the buffers and nothing more
+        std::vector<Hyprutils::Memory::CWeakPointer<CDRMDumbBuffer>> buffers;
+
+        Hyprutils::Memory::CWeakPointer<CBackend>                    backend;
+
+        int                                                          drmfd = -1;
+
+        friend class CDRMDumbBuffer;
+        friend class CDRMRenderer;
+    };
+};

include/aquamarine/backend/Backend.hpp

@@ -78,6 +78,7 @@ namespace Aquamarine {
         virtual bool                                                       createOutput(const std::string& name = "") = 0; // "" means auto
         virtual Hyprutils::Memory::CSharedPointer<IAllocator>              preferredAllocator()                       = 0;
         virtual std::vector<SDRMFormat>                                    getRenderableFormats(); // empty = use getRenderFormats
+        virtual std::vector<Hyprutils::Memory::CSharedPointer<IAllocator>> getAllocators() = 0;
     };
 
     class CBackend {

include/aquamarine/backend/DRM.hpp

@@ -15,6 +15,7 @@ namespace Aquamarine {
     class CDRMOutput;
     struct SDRMConnector;
     class CDRMRenderer;
+    class CDRMDumbAllocator;
 
     typedef std::function<void(void)> FIdleCallback;
 
@@ -353,6 +354,7 @@ namespace Aquamarine {
         virtual bool                                                       createOutput(const std::string& name = "");
         virtual Hyprutils::Memory::CSharedPointer<IAllocator>              preferredAllocator();
         virtual std::vector<SDRMFormat>                                    getRenderableFormats();
+        virtual std::vector<Hyprutils::Memory::CSharedPointer<IAllocator>> getAllocators();
 
         Hyprutils::Memory::CWeakPointer<CDRMBackend>                       self;
 
@@ -396,6 +398,8 @@ namespace Aquamarine {
         std::vector<SDRMFormat>                                       formats;
         std::vector<SDRMFormat>                                       glFormats;
 
+        Hyprutils::Memory::CSharedPointer<CDRMDumbAllocator>          dumbAllocator;
+
         bool                                                          atomic = false;
 
         struct {

include/aquamarine/backend/Headless.hpp

@@ -8,6 +8,7 @@
 namespace Aquamarine {
     class CBackend;
     class CHeadlessBackend;
+    class IAllocator;
 
     class CHeadlessOutput : public IOutput {
       public:
@@ -47,6 +48,7 @@ namespace Aquamarine {
         virtual std::vector<SDRMFormat>                                    getCursorFormats();
         virtual bool                                                       createOutput(const std::string& name = "");
         virtual Hyprutils::Memory::CSharedPointer<IAllocator>              preferredAllocator();
+        virtual std::vector<Hyprutils::Memory::CSharedPointer<IAllocator>> getAllocators();
 
         Hyprutils::Memory::CWeakPointer<CHeadlessBackend>                  self;
 

include/aquamarine/backend/Wayland.hpp

@@ -135,6 +135,7 @@ namespace Aquamarine {
         virtual std::vector<SDRMFormat>                                    getCursorFormats();
         virtual bool                                                       createOutput(const std::string& name = "");
         virtual Hyprutils::Memory::CSharedPointer<IAllocator>              preferredAllocator();
+        virtual std::vector<Hyprutils::Memory::CSharedPointer<IAllocator>> getAllocators();
 
         Hyprutils::Memory::CWeakPointer<CWaylandBackend>                   self;
 

include/aquamarine/buffer/Buffer.hpp

@@ -60,6 +60,7 @@ namespace Aquamarine {
         virtual void                                   lock();
         virtual void                                   unlock();
         virtual bool                                   locked();
+        virtual uint32_t                               drmHandle();
 
         Hyprutils::Math::Vector2D                      size;
         bool                                           opaque          = false;

src/allocator/DRMDumb.cpp

@@ -0,0 +1,142 @@
+#include <aquamarine/allocator/DRMDumb.hpp>
+#include <aquamarine/backend/Backend.hpp>
+#include <aquamarine/backend/DRM.hpp>
+#include <aquamarine/allocator/Swapchain.hpp>
+#include "FormatUtils.hpp"
+#include "Shared.hpp"
+#include <xf86drm.h>
+#include <unistd.h>
+#include <cstring>
+#include <sys/mman.h>
+#include "../backend/drm/Renderer.hpp"
+
+using namespace Aquamarine;
+using namespace Hyprutils::Memory;
+#define SP CSharedPointer
+#define WP CWeakPointer
+
+Aquamarine::CDRMDumbBuffer::CDRMDumbBuffer(const SAllocatorBufferParams& params, Hyprutils::Memory::CWeakPointer<CDRMDumbAllocator> allocator_,
+                                           Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain) : allocator(allocator_) {
+    attrs.format = params.format;
+
+    drm_mode_create_dumb request = {
+        .height = (uint32_t)params.size.y,
+        .width  = (uint32_t)params.size.x,
+        .bpp    = 32,
+    };
+
+    if (int ret = drmIoctl(allocator->drmFD(), DRM_IOCTL_MODE_CREATE_DUMB, &request); ret < 0) {
+        allocator->backend->log(AQ_LOG_ERROR, std::format("failed to create a drm_dumb buffer: {}", strerror(-ret)));
+        return;
+    }
+
+    stride    = request.pitch;
+    handle    = request.handle;
+    size      = request.size;
+    pixelSize = {(double)request.width, (double)request.height};
+
+    attrs.size = pixelSize;
+    attrs.fd   = request.handle;
+
+    drm_mode_map_dumb request2 = {
+        .handle = handle,
+    };
+
+    if (int ret = drmIoctl(allocator->drmFD(), DRM_IOCTL_MODE_MAP_DUMB, &request2); ret < 0) {
+        allocator->backend->log(AQ_LOG_ERROR, std::format("failed to map a drm_dumb buffer: {}", strerror(-ret)));
+        return;
+    }
+
+    data = (uint8_t*)mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, allocator->drmFD(), request2.offset);
+    if (!data) {
+        allocator->backend->log(AQ_LOG_ERROR, "failed to mmmap a drm_dumb buffer");
+        return;
+    }
+
+    // null the entire buffer so we dont get garbage
+    memset(data, 0x00, size);
+
+    attrs.success = true;
+}
+
+Aquamarine::CDRMDumbBuffer::~CDRMDumbBuffer() {
+    events.destroy.emit();
+
+    if (handle == 0)
+        return;
+
+    if (data)
+        munmap(data, size);
+
+    drm_mode_destroy_dumb request = {
+        .handle = handle,
+    };
+    drmIoctl(allocator->drmFD(), DRM_IOCTL_MODE_DESTROY_DUMB, &request);
+}
+
+eBufferCapability Aquamarine::CDRMDumbBuffer::caps() {
+    return eBufferCapability::BUFFER_CAPABILITY_DATAPTR;
+}
+
+eBufferType Aquamarine::CDRMDumbBuffer::type() {
+    return eBufferType::BUFFER_TYPE_SHM;
+}
+
+void Aquamarine::CDRMDumbBuffer::update(const Hyprutils::Math::CRegion& damage) {
+    ; // nothing to do
+}
+
+bool Aquamarine::CDRMDumbBuffer::isSynchronous() {
+    return true;
+}
+
+bool Aquamarine::CDRMDumbBuffer::good() {
+    return attrs.success && data;
+}
+
+SSHMAttrs Aquamarine::CDRMDumbBuffer::shm() {
+    return attrs;
+}
+
+std::tuple<uint8_t*, uint32_t, size_t> Aquamarine::CDRMDumbBuffer::beginDataPtr(uint32_t flags) {
+    return {data, attrs.format, size};
+}
+
+void Aquamarine::CDRMDumbBuffer::endDataPtr() {
+    ; // nothing to do
+}
+
+uint32_t Aquamarine::CDRMDumbBuffer::drmHandle() {
+    return handle;
+}
+
+Aquamarine::CDRMDumbAllocator::~CDRMDumbAllocator() {
+    ; // nothing to do
+}
+
+SP<CDRMDumbAllocator> Aquamarine::CDRMDumbAllocator::create(int drmfd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_) {
+    return SP<CDRMDumbAllocator>(new CDRMDumbAllocator(drmfd_, backend_));
+}
+
+SP<IBuffer> Aquamarine::CDRMDumbAllocator::acquire(const SAllocatorBufferParams& params, SP<CSwapchain> swapchain_) {
+    auto buf = SP<IBuffer>(new CDRMDumbBuffer(params, self, swapchain_));
+    if (!buf->good())
+        return nullptr;
+    return buf;
+}
+
+SP<CBackend> Aquamarine::CDRMDumbAllocator::getBackend() {
+    return backend.lock();
+}
+
+int Aquamarine::CDRMDumbAllocator::drmFD() {
+    return drmfd;
+}
+
+eAllocatorType Aquamarine::CDRMDumbAllocator::type() {
+    return eAllocatorType::AQ_ALLOCATOR_TYPE_DRM_DUMB;
+}
+
+Aquamarine::CDRMDumbAllocator::CDRMDumbAllocator(int fd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_) : drmfd(fd_), backend(backend_) {
+    ; // nothing to do
+}

src/backend/Headless.cpp

@@ -187,6 +187,10 @@ SP<IAllocator> Aquamarine::CHeadlessBackend::preferredAllocator() {
     return backend->primaryAllocator;
 }
 
+std::vector<SP<IAllocator>> Aquamarine::CHeadlessBackend::getAllocators() {
+    return {backend->primaryAllocator};
+}
+
 bool Aquamarine::CHeadlessBackend::CTimer::expired() {
     return std::chrono::steady_clock::now() > when;
 }

src/backend/Wayland.cpp

@@ -442,6 +442,10 @@ SP<IAllocator> Aquamarine::CWaylandBackend::preferredAllocator() {
     return backend->primaryAllocator;
 }
 
+std::vector<SP<IAllocator>> Aquamarine::CWaylandBackend::getAllocators() {
+    return {backend->primaryAllocator};
+}
+
 Aquamarine::CWaylandOutput::CWaylandOutput(const std::string& name_, Hyprutils::Memory::CWeakPointer<CWaylandBackend> backend_) : backend(backend_) {
     name = name_;
 

src/backend/drm/DRM.cpp

@@ -3,6 +3,7 @@
 #include <aquamarine/backend/drm/Legacy.hpp>
 #include <aquamarine/backend/drm/Atomic.hpp>
 #include <aquamarine/allocator/GBM.hpp>
+#include <aquamarine/allocator/DRMDumb.hpp>
 #include <hyprutils/string/VarList.hpp>
 #include <chrono>
 #include <thread>
@@ -961,6 +962,10 @@ SP<IAllocator> Aquamarine::CDRMBackend::preferredAllocator() {
     return backend->primaryAllocator;
 }
 
+std::vector<SP<IAllocator>> Aquamarine::CDRMBackend::getAllocators() {
+    return {backend->primaryAllocator, dumbAllocator};
+}
+
 bool Aquamarine::SDRMPlane::init(drmModePlane* plane) {
     id = plane->plane_id;
 
@@ -1647,8 +1652,10 @@ SP<IBackendImplementation> Aquamarine::CDRMOutput::getBackend() {
 }
 
 bool Aquamarine::CDRMOutput::setCursor(SP<IBuffer> buffer, const Vector2D& hotspot) {
-    if (buffer && !buffer->dmabuf().success) {
+    auto bufferType = buffer->type();
-        backend->backend->log(AQ_LOG_ERROR, "drm: Cursor buffer has to be a dmabuf");
+
+    if ((bufferType == eBufferType::BUFFER_TYPE_SHM && !buffer->shm().success) || (bufferType == eBufferType::BUFFER_TYPE_DMABUF && !buffer->dmabuf().success)) {
+        backend->backend->log(AQ_LOG_ERROR, "drm: Invalid buffer passed to setCursor");
         return false;
     }
 
@@ -1663,17 +1670,22 @@ bool Aquamarine::CDRMOutput::setCursor(SP<IBuffer> buffer, const Vector2D& hotsp
         if (backend->primary) {
             TRACE(backend->backend->log(AQ_LOG_TRACE, "drm: Backend requires cursor blit, blitting"));
 
+            // TODO: will this not implode on drm_dumb?!
+
             if (!mgpu.cursorSwapchain) {
                 TRACE(backend->backend->log(AQ_LOG_TRACE, "drm: No cursorSwapchain for blit, creating"));
                 mgpu.cursorSwapchain = CSwapchain::create(backend->rendererState.allocator, backend.lock());
             }
 
+            const auto FORMAT = bufferType == eBufferType::BUFFER_TYPE_SHM ? buffer->shm().format : buffer->dmabuf().format;
+            const auto SIZE   = bufferType == eBufferType::BUFFER_TYPE_SHM ? buffer->shm().size : buffer->dmabuf().size;
+
             auto       OPTIONS = mgpu.cursorSwapchain->currentOptions();
             OPTIONS.multigpu   = false;
             OPTIONS.scanout    = true;
             OPTIONS.cursor     = true;
-            OPTIONS.format   = buffer->dmabuf().format;
+            OPTIONS.format     = FORMAT;
-            OPTIONS.size     = buffer->dmabuf().size;
+            OPTIONS.size       = SIZE;
             OPTIONS.length     = 2;
 
             if (!mgpu.cursorSwapchain->reconfigure(OPTIONS)) {
@@ -1807,8 +1819,8 @@ Aquamarine::CDRMFB::CDRMFB(SP<IBuffer> buffer_, Hyprutils::Memory::CWeakPointer<
 
 void Aquamarine::CDRMFB::import() {
     auto attrs = buffer->dmabuf();
-    if (!attrs.success) {
+    if (!attrs.success && !buffer->drmHandle()) {
-        backend->backend->log(AQ_LOG_ERROR, "drm: Buffer submitted has no dmabuf");
+        backend->backend->log(AQ_LOG_ERROR, "drm: Buffer submitted has no dmabuf or a drm handle");
         return;
     }
 
@@ -1819,6 +1831,7 @@ void Aquamarine::CDRMFB::import() {
 
     // TODO: check format
 
+    if (!buffer->drmHandle()) {
         for (int i = 0; i < attrs.planes; ++i) {
             int ret = drmPrimeFDToHandle(backend->gpu->fd, attrs.fds.at(i), &boHandles[i]);
             if (ret) {
@@ -1829,6 +1842,8 @@ void Aquamarine::CDRMFB::import() {
 
             TRACE(backend->backend->log(AQ_LOG_TRACE, std::format("drm: CDRMFB: plane {} has fd {}, got handle {}", i, attrs.fds.at(i), boHandles.at(i))));
         }
+    } else
+        boHandles = {buffer->drmHandle(), 0, 0, 0};
 
     id = submitBuffer();
     if (!id) {
@@ -1915,8 +1930,12 @@ void Aquamarine::CDRMFB::drop() {
 }
 
 uint32_t Aquamarine::CDRMFB::submitBuffer() {
-    auto                    attrs = buffer->dmabuf();
     uint32_t newID = 0;
+
+    if (buffer->type() == eBufferType::BUFFER_TYPE_DMABUF) {
+
+        auto                    attrs = buffer->dmabuf();
+
         std::array<uint64_t, 4> mods = {0, 0, 0, 0};
         for (size_t i = 0; i < attrs.planes; ++i) {
             mods[i] = attrs.modifier;
@@ -1946,6 +1965,16 @@ uint32_t Aquamarine::CDRMFB::submitBuffer() {
                 return 0;
             }
         }
+    } else {
+        auto           attrs      = buffer->shm();
+        const uint32_t strides[4] = {(uint32_t)attrs.stride, 0, 0, 0};
+        const uint32_t offsets[4] = {0, 0, 0, 0};
+
+        if (drmModeAddFB2(backend->gpu->fd, attrs.size.x, attrs.size.y, attrs.format, boHandles.data(), strides, offsets, &newID, 0)) {
+            backend->backend->log(AQ_LOG_ERROR, "drm: Failed to submit a shm buffer with drmModeAddFB2");
+            return 0;
+        }
+    }
 
     return newID;
 }

src/buffer/Buffer.cpp

@@ -39,3 +39,7 @@ void Aquamarine::IBuffer::unlock() {
 bool Aquamarine::IBuffer::locked() {
     return locks;
 }
+
+uint32_t Aquamarine::IBuffer::drmHandle() {
+    return 0;
+}