summaryrefslogtreecommitdiff
path: root/src/protocols/DRMLease.hpp
blob: 5ea1c4e2372d4fe531e21992b856873938558578 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#pragma once

#include <vector>
#include <unordered_map>
#include "WaylandProtocol.hpp"
#include "drm-lease-v1.hpp"
#include "../helpers/signal/Signal.hpp"
#include <hyprutils/os/FileDescriptor.hpp>

/*
    TODO: this protocol is not made for systems with multiple DRM nodes (e.g. multigpu)
*/

AQUAMARINE_FORWARD(CDRMBackend);
AQUAMARINE_FORWARD(CDRMLease);
class CDRMLeaseDeviceResource;
class CMonitor;
class CDRMLeaseProtocol;
class CDRMLeaseConnectorResource;
class CDRMLeaseRequestResource;

class CDRMLeaseResource {
  public:
    CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRequestResource> request);
    ~CDRMLeaseResource();

    bool                                        good();

    WP<CDRMLeaseDeviceResource>                 m_parent;
    std::vector<WP<CDRMLeaseConnectorResource>> m_requested;
    SP<Aquamarine::CDRMLease>                   m_lease;

    struct {
        CHyprSignalListener destroyLease;
    } m_listeners;

  private:
    SP<CWpDrmLeaseV1> m_resource;
};

class CDRMLeaseRequestResource {
  public:
    CDRMLeaseRequestResource(SP<CWpDrmLeaseRequestV1> resource_);

    bool                                        good();

    WP<CDRMLeaseDeviceResource>                 m_parent;
    WP<CDRMLeaseRequestResource>                m_self;
    std::vector<WP<CDRMLeaseConnectorResource>> m_requested;

  private:
    SP<CWpDrmLeaseRequestV1> m_resource;
};

class CDRMLeaseConnectorResource {
  public:
    CDRMLeaseConnectorResource(SP<CWpDrmLeaseConnectorV1> resource_, PHLMONITOR monitor_);
    static SP<CDRMLeaseConnectorResource> fromResource(wl_resource*);

    bool                                  good();
    void                                  sendData();

    WP<CDRMLeaseConnectorResource>        m_self;
    WP<CDRMLeaseDeviceResource>           m_parent;
    PHLMONITORREF                         m_monitor;
    bool                                  m_dead = false;

  private:
    SP<CWpDrmLeaseConnectorV1> m_resource;

    struct {
        CHyprSignalListener destroyMonitor;
    } m_listeners;

    friend class CDRMLeaseDeviceResource;
};

class CDRMLeaseDeviceResource {
  public:
    CDRMLeaseDeviceResource(SP<CWpDrmLeaseDeviceV1> resource_);

    bool                                        good();
    void                                        sendConnector(PHLMONITOR monitor);

    std::vector<WP<CDRMLeaseConnectorResource>> m_connectorsSent;

    WP<CDRMLeaseDeviceResource>                 m_self;

  private:
    SP<CWpDrmLeaseDeviceV1> m_resource;

    friend class CDRMLeaseProtocol;
};

class CDRMLeaseDevice {
  public:
    CDRMLeaseDevice(SP<Aquamarine::CDRMBackend> drmBackend);

    std::string                 m_name    = "";
    bool                        m_success = false;
    SP<Aquamarine::CDRMBackend> m_backend;

    std::vector<PHLMONITORREF>  m_offeredOutputs;
};

class CDRMLeaseProtocol : public IWaylandProtocol {
  public:
    CDRMLeaseProtocol(const wl_interface* iface, const int& ver, const std::string& name);

    virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);

    void         offer(PHLMONITOR monitor);

  private:
    void destroyResource(CDRMLeaseDeviceResource* resource);
    void destroyResource(CDRMLeaseConnectorResource* resource);
    void destroyResource(CDRMLeaseRequestResource* resource);
    void destroyResource(CDRMLeaseResource* resource);

    //
    std::vector<SP<CDRMLeaseDeviceResource>>    m_managers;
    std::vector<SP<CDRMLeaseConnectorResource>> m_connectors;
    std::vector<SP<CDRMLeaseRequestResource>>   m_requests;
    std::vector<SP<CDRMLeaseResource>>          m_leases;

    SP<CDRMLeaseDevice>                         m_primaryDevice;

    friend class CDRMLeaseDeviceResource;
    friend class CDRMLeaseConnectorResource;
    friend class CDRMLeaseRequestResource;
    friend class CDRMLeaseResource;
};

namespace PROTO {
    inline UP<CDRMLeaseProtocol> lease;
};