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 #define DEF_CONN(c) { DRM_MODE_CONNECTOR_##c, #c }
  18         DEF_CONN(Unknown),
  19         DEF_CONN(VGA),
  20         DEF_CONN(DVII),
  21         DEF_CONN(DVID),
  22         DEF_CONN(DVIA),
  23         DEF_CONN(Composite),
  24         DEF_CONN(SVIDEO),
  25         DEF_CONN(LVDS),
  26         DEF_CONN(Component),
  27         DEF_CONN(9PinDIN),
  28         DEF_CONN(DisplayPort),
  29         DEF_CONN(HDMIA),
  30         DEF_CONN(HDMIB),
  31         DEF_CONN(TV),
  32         DEF_CONN(eDP),
  33         DEF_CONN(VIRTUAL),
  34         DEF_CONN(DSI),
  35 #undef DEF_CONN
  36 };
  37
  38 static const map<int, string> connection_str = {
  39         { 0, "<unknown>" },
  40         { DRM_MODE_CONNECTED, "Connected" },
  41         { DRM_MODE_DISCONNECTED, "Disconnected" },
  42         { DRM_MODE_UNKNOWNCONNECTION, "Unknown" },
  43 };
  44
  45 static const map<int, string> subpix_str = {
  46 #define DEF_SUBPIX(c) { DRM_MODE_SUBPIXEL_##c, #c }
  47         DEF_SUBPIX(UNKNOWN),
  48         DEF_SUBPIX(HORIZONTAL_RGB),
  49         DEF_SUBPIX(HORIZONTAL_BGR),
  50         DEF_SUBPIX(VERTICAL_RGB),
  51         DEF_SUBPIX(VERTICAL_BGR),
  52         DEF_SUBPIX(NONE),
  53 #undef DEF_SUBPIX
  54 };
  55
  56 struct ConnectorPriv
  57 {
  58         drmModeConnectorPtr drm_connector;
  59 };
  60
  61 Connector::Connector(Card &card, uint32_t id, uint32_t idx)
  62         :DrmObject(card, id, DRM_MODE_OBJECT_CONNECTOR, idx)
  63 {
  64         m_priv = new ConnectorPriv();
  65
  66         m_priv->drm_connector = drmModeGetConnector(this->card().fd(), this->id());
  67         assert(m_priv->drm_connector);
  68
  69         const auto& name = connector_names.at(m_priv->drm_connector->connector_type);
  70         m_fullname = name + to_string(m_priv->drm_connector->connector_type_id);
  71 }
  72
  73
  74 Connector::~Connector()
  75 {
  76         drmModeFreeConnector(m_priv->drm_connector);
  77         delete m_priv;
  78 }
  79
  80 void Connector::setup()
  81 {
  82         if (m_priv->drm_connector->encoder_id != 0)
  83                 m_current_encoder = card().get_encoder(m_priv->drm_connector->encoder_id);
  84         else
  85                 m_current_encoder = 0;
  86
  87         if (m_current_encoder)
  88                 m_saved_crtc = m_current_encoder->get_crtc();
  89         else
  90                 m_saved_crtc = 0;
  91 }
  92
  93 void Connector::restore_mode()
  94 {
  95         if (m_saved_crtc)
  96                 m_saved_crtc->restore_mode(this);
  97 }
  98
  99 Videomode Connector::get_default_mode() const
 100 {
 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 bool Connector::connected() const
 118 {
 119         return m_priv->drm_connector->connection == DRM_MODE_CONNECTED;
 120 }
 121
 122 vector<Crtc*> Connector::get_possible_crtcs() const
 123 {
 124         vector<Crtc*> crtcs;
 125
 126         for (int i = 0; i < m_priv->drm_connector->count_encoders; ++i) {
 127                 auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
 128
 129                 auto l = enc->get_possible_crtcs();
 130
 131                 crtcs.insert(crtcs.end(), l.begin(), l.end());
 132         }
 133
 134         return crtcs;
 135 }
 136
 137 Crtc* Connector::get_current_crtc() const
 138 {
 139         if (m_current_encoder)
 140                 return m_current_encoder->get_crtc();
 141         else
 142                 return 0;
 143 }
 144
 145 uint32_t Connector::connector_type() const
 146 {
 147         return m_priv->drm_connector->connector_type;
 148 }
 149
 150 uint32_t Connector::connector_type_id() const
 151 {
 152         return m_priv->drm_connector->connector_type_id;
 153 }
 154
 155 uint32_t Connector::mmWidth() const
 156 {
 157         return m_priv->drm_connector->mmWidth;
 158 }
 159
 160 uint32_t Connector::mmHeight() const
 161 {
 162         return m_priv->drm_connector->mmHeight;
 163 }
 164
 165 uint32_t Connector::subpixel() const
 166 {
 167         return m_priv->drm_connector->subpixel;
 168 }
 169
 170 const string& Connector::subpixel_str() const
 171 {
 172         return subpix_str.at(subpixel());
 173 }
 174
 175 std::vector<Videomode> Connector::get_modes() const
 176 {
 177         vector<Videomode> modes;
 178
 179         for (int i = 0; i < m_priv->drm_connector->count_modes; i++)
 180                 modes.push_back(drm_mode_to_video_mode(
 181                                         m_priv->drm_connector->modes[i]));
 182
 183         return modes;
 184 }
 185
 186 std::vector<Encoder*> Connector::get_encoders() const
 187 {
 188         vector<Encoder*> encoders;
 189
 190         for (int i = 0; i < m_priv->drm_connector->count_encoders; i++) {
 191                 auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
 192                 encoders.push_back(enc);
 193         }
 194         return encoders;
 195 }
 196
 197 }