wayland/core: move to new impl (#6268)

* wayland/core/dmabuf: move to new impl

it's the final countdown

src/protocols/LinuxDMABUF.hpp

@@ -0,0 +1,138 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <cstdint>
+#include "WaylandProtocol.hpp"
+#include "wayland.hpp"
+#include "linux-dmabuf-v1.hpp"
+#include "../helpers/signal/Signal.hpp"
+
+class CDMABuffer;
+struct SDRMFormat;
+struct SDMABUFAttrs;
+class CWLSurfaceResource;
+
+class CLinuxDMABuffer {
+  public:
+    CLinuxDMABuffer(uint32_t id, wl_client* client, SDMABUFAttrs attrs);
+    ~CLinuxDMABuffer();
+
+    bool good();
+
+  private:
+    SP<CDMABuffer> buffer;
+
+    struct {
+        CHyprSignalListener bufferResourceDestroy;
+    } listeners;
+
+    friend class CLinuxDMABBUFParamsResource;
+};
+
+#pragma pack(push, 1)
+struct SDMABUFFeedbackTableEntry {
+    uint32_t fmt = 0;
+    char     pad[4];
+    uint64_t modifier = 0;
+};
+#pragma pack(pop)
+
+class SCompiledDMABUFTranche {
+    dev_t                 device = 0;
+    uint32_t              flags  = 0;
+    std::vector<uint16_t> indices;
+};
+
+struct SDMABufTranche {
+    dev_t                   device = 0;
+    uint32_t                flags  = 0;
+    std::vector<SDRMFormat> formats;
+};
+
+class CCompiledDMABUFFeedback {
+  public:
+    CCompiledDMABUFFeedback(dev_t device, std::vector<SDMABufTranche> tranches);
+    ~CCompiledDMABUFFeedback();
+
+    dev_t                                      mainDevice = 0;
+    int                                        tableFD    = -1;
+    size_t                                     tableLen   = 0;
+    std::vector<std::pair<uint32_t, uint64_t>> tranches;
+};
+
+class CLinuxDMABBUFParamsResource {
+  public:
+    CLinuxDMABBUFParamsResource(SP<CZwpLinuxBufferParamsV1> resource_);
+    ~CLinuxDMABBUFParamsResource();
+
+    bool                good();
+    void                create(uint32_t id); // 0 means not immed
+
+    SP<SDMABUFAttrs>    attrs;
+    WP<CLinuxDMABuffer> createdBuffer;
+    bool                used = false;
+
+  private:
+    SP<CZwpLinuxBufferParamsV1> resource;
+
+    bool                        verify();
+    bool                        commence();
+};
+
+class CLinuxDMABUFFeedbackResource {
+  public:
+    CLinuxDMABUFFeedbackResource(SP<CZwpLinuxDmabufFeedbackV1> resource_, SP<CWLSurfaceResource> surface_);
+    ~CLinuxDMABUFFeedbackResource();
+
+    bool                   good();
+
+    SP<CWLSurfaceResource> surface; // optional, for surface feedbacks
+
+  private:
+    SP<CZwpLinuxDmabufFeedbackV1> resource;
+};
+
+class CLinuxDMABUFResource {
+  public:
+    CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_);
+
+    bool good();
+    void sendMods();
+
+  private:
+    SP<CZwpLinuxDmabufV1> resource;
+};
+
+class CLinuxDMABufV1Protocol : public IWaylandProtocol {
+  public:
+    CLinuxDMABufV1Protocol(const wl_interface* iface, const int& ver, const std::string& name);
+    ~CLinuxDMABufV1Protocol();
+
+    virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
+
+  private:
+    void destroyResource(CLinuxDMABUFResource* resource);
+    void destroyResource(CLinuxDMABUFFeedbackResource* resource);
+    void destroyResource(CLinuxDMABBUFParamsResource* resource);
+    void destroyResource(CLinuxDMABuffer* resource);
+
+    //
+    std::vector<SP<CLinuxDMABUFResource>>         m_vManagers;
+    std::vector<SP<CLinuxDMABUFFeedbackResource>> m_vFeedbacks;
+    std::vector<SP<CLinuxDMABBUFParamsResource>>  m_vParams;
+    std::vector<SP<CLinuxDMABuffer>>              m_vBuffers;
+
+    UP<CCompiledDMABUFFeedback>                   defaultFeedback;
+    dev_t                                         mainDevice;
+    int                                           mainDeviceFD = -1;
+
+    friend class CLinuxDMABUFResource;
+    friend class CLinuxDMABUFFeedbackResource;
+    friend class CLinuxDMABBUFParamsResource;
+    friend class CLinuxDMABuffer;
+};
+
+namespace PROTO {
+    inline UP<CLinuxDMABufV1Protocol> linuxDma;
+};