libkms++/connector.cpp

   1 #include <stdio.h>
   2 #include <iostream>
   3 #include <unistd.h>
   4 #include <fcntl.h>
   5 #include <cassert>
   6
   7 #include "kms++.h"
   8 #include "helpers.h"
   9
  10 using namespace std;
  11
  12 namespace kms
  13 {
  14
  15
  16 static const map<int, string> connector_names = {
  17         { DRM_MODE_CONNECTOR_Unknown, "Unknown" },
  18         { DRM_MODE_CONNECTOR_VGA, "VGA" },
  19         { DRM_MODE_CONNECTOR_DVII, "DVI-I" },
  20         { DRM_MODE_CONNECTOR_DVID, "DVI-D" },
  21         { DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
  22         { DRM_MODE_CONNECTOR_Composite, "Composite" },
  23         { DRM_MODE_CONNECTOR_SVIDEO, "S-Video" },
  24         { DRM_MODE_CONNECTOR_LVDS, "LVDS" },
  25         { DRM_MODE_CONNECTOR_Component, "Component" },
  26         { DRM_MODE_CONNECTOR_9PinDIN, "9-Pin-DIN" },
  27         { DRM_MODE_CONNECTOR_DisplayPort, "DP" },
  28         { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
  29         { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
  30         { DRM_MODE_CONNECTOR_TV, "TV" },
  31         { DRM_MODE_CONNECTOR_eDP, "eDP" },
  32         { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
  33         { DRM_MODE_CONNECTOR_DSI, "DSI" },
  34 };
  35
  36 static const map<int, string> connection_str = {
  37         { 0, "<unknown>" },
  38         { DRM_MODE_CONNECTED, "Connected" },
  39         { DRM_MODE_DISCONNECTED, "Disconnected" },
  40         { DRM_MODE_UNKNOWNCONNECTION, "Unknown" },
  41 };
  42
  43 static const map<int, string> subpix_str = {
  44 #define DEF_SUBPIX(c) { DRM_MODE_SUBPIXEL_##c, #c }
  45         DEF_SUBPIX(UNKNOWN),
  46         DEF_SUBPIX(HORIZONTAL_RGB),
  47         DEF_SUBPIX(HORIZONTAL_BGR),
  48         DEF_SUBPIX(VERTICAL_RGB),
  49         DEF_SUBPIX(VERTICAL_BGR),
  50         DEF_SUBPIX(NONE),
  51 #undef DEF_SUBPIX
  52 };
  53
  54 struct ConnectorPriv
  55 {
  56         drmModeConnectorPtr drm_connector;
  57 };
  58
  59 Connector::Connector(Card &card, uint32_t id, uint32_t idx)
  60         :DrmObject(card, id, DRM_MODE_OBJECT_CONNECTOR, idx)
  61 {
  62         m_priv = new ConnectorPriv();
  63
  64         m_priv->drm_connector = drmModeGetConnector(this->card().fd(), this->id());
  65         assert(m_priv->drm_connector);
  66
  67         const auto& name = connector_names.at(m_priv->drm_connector->connector_type);
  68         m_fullname = name + "-" + to_string(m_priv->drm_connector->connector_type_id);
  69 }
  70
  71
  72 Connector::~Connector()
  73 {
  74         drmModeFreeConnector(m_priv->drm_connector);
  75         delete m_priv;
  76 }
  77
  78 void Connector::setup()
  79 {
  80         if (m_priv->drm_connector->encoder_id != 0)
  81                 m_current_encoder = card().get_encoder(m_priv->drm_connector->encoder_id);
  82         else
  83                 m_current_encoder = 0;
  84
  85         if (m_current_encoder)
  86                 m_saved_crtc = m_current_encoder->get_crtc();
  87         else
  88                 m_saved_crtc = 0;
  89 }
  90
  91 void Connector::restore_mode()
  92 {
  93         if (m_saved_crtc)
  94                 m_saved_crtc->restore_mode(this);
  95 }
  96
  97 Videomode Connector::get_default_mode() const
  98 {
  99         if (m_priv->drm_connector->count_modes == 0)
 100                 throw invalid_argument("no modes available\n");
 101         drmModeModeInfo drmmode = m_priv->drm_connector->modes[0];
 102
 103         return drm_mode_to_video_mode(drmmode);
 104 }
 105
 106 Videomode Connector::get_mode(const string& mode) const
 107 {
 108         auto c = m_priv->drm_connector;
 109
 110         for (int i = 0; i < c->count_modes; i++)
 111                 if (mode == c->modes[i].name)
 112                         return drm_mode_to_video_mode(c->modes[i]);
 113
 114         throw invalid_argument(mode + ": mode not found");
 115 }
 116
 117 Videomode Connector::get_mode(unsigned xres, unsigned yres, unsigned refresh, bool ilace) const
 118 {
 119         auto c = m_priv->drm_connector;
 120
 121         for (int i = 0; i < c->count_modes; i++) {
 122                 drmModeModeInfo& m = c->modes[i];
 123
 124                 if (m.hdisplay != xres || m.vdisplay != yres)
 125                         continue;
 126
 127                 if (refresh && m.vrefresh != refresh)
 128                         continue;
 129
 130                 if (ilace != !!(m.flags & DRM_MODE_FLAG_INTERLACE))
 131                         continue;
 132
 133                 return drm_mode_to_video_mode(c->modes[i]);
 134         }
 135
 136         throw invalid_argument("mode not found");
 137 }
 138
 139 bool Connector::connected() const
 140 {
 141         return m_priv->drm_connector->connection == DRM_MODE_CONNECTED ||
 142                         m_priv->drm_connector->connection == DRM_MODE_UNKNOWNCONNECTION;
 143 }
 144
 145 vector<Crtc*> Connector::get_possible_crtcs() const
 146 {
 147         vector<Crtc*> crtcs;
 148
 149         for (int i = 0; i < m_priv->drm_connector->count_encoders; ++i) {
 150                 auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
 151
 152                 auto l = enc->get_possible_crtcs();
 153
 154                 crtcs.insert(crtcs.end(), l.begin(), l.end());
 155         }
 156
 157         return crtcs;
 158 }
 159
 160 Crtc* Connector::get_current_crtc() const
 161 {
 162         if (m_current_encoder)
 163                 return m_current_encoder->get_crtc();
 164         else
 165                 return 0;
 166 }
 167
 168 uint32_t Connector::connector_type() const
 169 {
 170         return m_priv->drm_connector->connector_type;
 171 }
 172
 173 uint32_t Connector::connector_type_id() const
 174 {
 175         return m_priv->drm_connector->connector_type_id;
 176 }
 177
 178 uint32_t Connector::mmWidth() const
 179 {
 180         return m_priv->drm_connector->mmWidth;
 181 }
 182
 183 uint32_t Connector::mmHeight() const
 184 {
 185         return m_priv->drm_connector->mmHeight;
 186 }
 187
 188 uint32_t Connector::subpixel() const
 189 {
 190         return m_priv->drm_connector->subpixel;
 191 }
 192
 193 const string& Connector::subpixel_str() const
 194 {
 195         return subpix_str.at(subpixel());
 196 }
 197
 198 std::vector<Videomode> Connector::get_modes() const
 199 {
 200         vector<Videomode> modes;
 201
 202         for (int i = 0; i < m_priv->drm_connector->count_modes; i++)
 203                 modes.push_back(drm_mode_to_video_mode(
 204                                         m_priv->drm_connector->modes[i]));
 205
 206         return modes;
 207 }
 208
 209 std::vector<Encoder*> Connector::get_encoders() const
 210 {
 211         vector<Encoder*> encoders;
 212
 213         for (int i = 0; i < m_priv->drm_connector->count_encoders; i++) {
 214                 auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
 215                 encoders.push_back(enc);
 216         }
 217         return encoders;
 218 }
 219
 220 }