Fb: collect fbs and destroy them in card's destructor
[android/external-libkmsxx.git] / libkms++ / card.cpp
1 #include <stdio.h>
2 #include <unistd.h>
3 #include <fcntl.h>
4 #include <utility>
5 #include <stdexcept>
6 #include <string.h>
7 #include <algorithm>
9 #include <xf86drm.h>
10 #include <xf86drmMode.h>
12 #include "kms++.h"
14 using namespace std;
16 namespace kms
17 {
19 Card::Card()
20 {
21         const char *card = "/dev/dri/card0";
23         int fd = open(card, O_RDWR | O_CLOEXEC);
24         if (fd < 0)
25                 throw invalid_argument(string(strerror(errno)) + " opening " +
26                                        card);
27         m_fd = fd;
29         int r;
31         r = drmSetMaster(fd);
32         m_master = r == 0;
34         if (getenv("LIBKMSXX_DISABLE_UNIVERSAL_PLANES") == 0) {
35                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
36                 m_has_universal_planes = r == 0;
37         } else {
38                 m_has_universal_planes = false;
39         }
41 #ifdef DRM_CLIENT_CAP_ATOMIC
42         if (getenv("LIBKMSXX_DISABLE_ATOMIC") == 0) {
43                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
44                 m_has_atomic = r == 0;
45         } else {
46                 m_has_atomic = false;
47         }
48 #else
49         m_has_atomic = false;
50 #endif
52         uint64_t has_dumb;
53         r = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
54         if (r || !has_dumb)
55                 throw invalid_argument("Dumb buffers not available");
57         auto res = drmModeGetResources(m_fd);
58         if (!res)
59                 throw invalid_argument("Can't get card resources");
61         for (int i = 0; i < res->count_connectors; ++i) {
62                 uint32_t id = res->connectors[i];
63                 auto ob = new Connector(*this, id, i);
64                 m_obmap[id] = ob;
65                 m_connectors.push_back(ob);
66         }
68         for (int i = 0; i < res->count_crtcs; ++i) {
69                 uint32_t id = res->crtcs[i];
70                 auto ob = new Crtc(*this, id, i);
71                 m_obmap[id] = ob;
72                 m_crtcs.push_back(ob);
73         }
75         for (int i = 0; i < res->count_encoders; ++i) {
76                 uint32_t id = res->encoders[i];
77                 auto ob = new Encoder(*this, id);
78                 m_obmap[id] = ob;
79                 m_encoders.push_back(ob);
80         }
82         drmModeFreeResources(res);
84         auto planeRes = drmModeGetPlaneResources(m_fd);
86         for (uint i = 0; i < planeRes->count_planes; ++i) {
87                 uint32_t id = planeRes->planes[i];
88                 auto ob = new Plane(*this, id);
89                 m_obmap[id] = ob;
90                 m_planes.push_back(ob);
91         }
93         drmModeFreePlaneResources(planeRes);
95         // collect all possible props
96         for (auto ob : get_objects()) {
97                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
99                 if (props == nullptr)
100                         continue;
102                 for (unsigned i = 0; i < props->count_props; ++i) {
103                         uint32_t prop_id = props->props[i];
105                         if (m_obmap.find(prop_id) == m_obmap.end()) {
106                                 auto ob = new Property(*this, prop_id);
107                                 m_obmap[prop_id] = ob;
108                                 m_properties.push_back(ob);
109                         }
110                 }
112                 drmModeFreeObjectProperties(props);
113         }
115         for (auto pair : m_obmap)
116                 pair.second->setup();
119 Card::~Card()
121         restore_modes();
123         while (m_framebuffers.size() > 0)
124                 delete m_framebuffers.back();
126         for (auto pair : m_obmap)
127                 delete pair.second;
129         close(m_fd);
132 void Card::restore_modes()
134         for (auto conn : get_connectors())
135                 conn->restore_mode();
138 Property* Card::get_prop(const string& name) const
140         for (auto prop : m_properties) {
141                 if (name == prop->name())
142                         return prop;
143         }
145         throw invalid_argument(string("Card property ") + name + " not found");
148 Connector* Card::get_first_connected_connector() const
150         for(auto c : m_connectors) {
151                 if (c->connected())
152                         return c;
153         }
155         throw invalid_argument("no connected connectors");
158 DrmObject* Card::get_object(uint32_t id) const
160         return m_obmap.at(id);
163 const vector<DrmObject*> Card::get_objects() const
165         vector<DrmObject*> v;
166         for(auto pair : m_obmap)
167                 v.push_back(pair.second);
168         return v;
171 Crtc* Card::get_crtc_by_index(uint32_t idx) const
173         return m_crtcs[idx];
176 Connector* Card::get_connector(uint32_t id) const { return dynamic_cast<Connector*>(get_object(id)); }
177 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
178 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
179 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
180 Plane* Card::get_plane(uint32_t id) const { return dynamic_cast<Plane*>(get_object(id)); }
182 std::vector<kms::Pipeline> Card::get_connected_pipelines()
184         vector<Pipeline> outputs;
186         for (auto conn : get_connectors())
187         {
188                 if (conn->connected() == false)
189                         continue;
191                 Crtc* crtc = conn->get_current_crtc();
193                 if (!crtc) {
194                         for (auto possible : conn->get_possible_crtcs()) {
195                                 if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
196                                         crtc = possible;
197                                         break;
198                                 }
199                         }
200                 }
202                 if (!crtc)
203                         throw invalid_argument(string("Connector #") +
204                                                to_string(conn->idx()) +
205                                                " has no possible crtcs");
207                 outputs.push_back(Pipeline { crtc, conn });
208         }
210         return outputs;
213 static void page_flip_handler(int fd, unsigned int frame,
214                               unsigned int sec, unsigned int usec,
215                               void *data)
217         auto handler = (PageFlipHandlerBase*)data;
218         double time = sec + usec / 1000000.0;
219         handler->handle_page_flip(frame, time);
222 void Card::call_page_flip_handlers()
224         drmEventContext ev = {
225                 .version = DRM_EVENT_CONTEXT_VERSION,
226                 .vblank_handler = 0,
227                 .page_flip_handler = page_flip_handler,
228         };
230         drmHandleEvent(fd(), &ev);