Differential D11781 Diff 32270 plugins/platforms/drm/drm_output.cpp

Changeset View

Standalone View

View Options

plugins/platforms/drm/drm_output.cpp

Show All 30 Lines
31#include "main.h" 31​#include "main.h"
32#include "orientation_sensor.h" 32​#include "orientation_sensor.h"
33#include "screens_drm.h" 33​#include "screens_drm.h"
34#include "wayland_server.h" 34​#include "wayland_server.h"
35// KWayland 35​// KWayland
36#include <KWayland/Server/display.h> 36​#include <KWayland/Server/display.h>
37#include <KWayland/Server/output_interface.h> 37​#include <KWayland/Server/output_interface.h>
38#include <KWayland/Server/outputchangeset.h> 38​#include <KWayland/Server/outputchangeset.h>
39#include <KWayland/Server/outputdevice_interface.h> ​
40#include <KWayland/Server/outputmanagement_interface.h> 39​#include <KWayland/Server/outputmanagement_interface.h>
41#include <KWayland/Server/outputconfiguration_interface.h> 40​#include <KWayland/Server/outputconfiguration_interface.h>
42// KF5 41​// KF5
43#include <KConfigGroup> 42​#include <KConfigGroup>
44#include <KLocalizedString> 43​#include <KLocalizedString>
45#include <KSharedConfig> 44​#include <KSharedConfig>
46// Qt 45​// Qt
47#include <QMatrix4x4> 46​#include <QMatrix4x4>
48#include <QCryptographicHash> 47​#include <QCryptographicHash>
49#include <QPainter> 48​#include <QPainter>
50// drm 49​// drm
51#include <xf86drm.h> 50​#include <xf86drm.h>
52#include <xf86drmMode.h> 51​#include <xf86drmMode.h>
53#include <libdrm/drm_mode.h> 52​#include <libdrm/drm_mode.h>
54 53​
55 54​
56namespace KWin 55​namespace KWin
57{ 56​{
58 57​
59DrmOutput::DrmOutput(DrmBackend *backend) 58​DrmOutput::DrmOutput(DrmBackend *backend)
60 : QObject() 59​ : Output()
61 , m_backend(backend) 60​ , m_backend(backend)
62{ 61​{
63} 62​}
64 63​
65DrmOutput::~DrmOutput() 64​DrmOutput::~DrmOutput()
66{ 65​{
67 hideCursor(); 66​ hideCursor();
68 m_crtc->blank(); 67​ m_crtc->blank();
69 68​
70 if (m_primaryPlane) { 69​ if (m_primaryPlane) {
71 // TODO: when having multiple planes, also clean up these 70​ // TODO: when having multiple planes, also clean up these
72 m_primaryPlane->setOutput(nullptr); 71​ m_primaryPlane->setOutput(nullptr);
73 72​
74 if (m_backend->deleteBufferAfterPageFlip()) { 73​ if (m_backend->deleteBufferAfterPageFlip()) {
75 delete m_primaryPlane->current(); 74​ delete m_primaryPlane->current();
76 } 75​ }
77 m_primaryPlane->setCurrent(nullptr); 76​ m_primaryPlane->setCurrent(nullptr);
78 } 77​ }
79 78​
80 m_crtc->setOutput(nullptr); 79​ m_crtc->setOutput(nullptr);
81 m_conn->setOutput(nullptr); 80​ m_conn->setOutput(nullptr);
82 81​
83 delete m_waylandOutput.data(); 82​ delete getWaylandOutput().data();
84 delete m_waylandOutputDevice.data(); 83​ delete getWaylandOutputDevice().data();
zzagUnsubmitted
Done

Is it safe? Shouldn't you test the pointer for validity?
Also, it looks like DrmOutput deletes objects that it doesn't own. Is it a good idea?

zzag: Is it safe? Shouldn't you test the pointer for validity? Also, it looks like DrmOutput deletes…
romanggAuthorUnsubmitted
Done

You can delete a nullptr.

But in general yes, the waylandOutput() and waylandOutputDevice() data fields should be deleted on Output level. I just wanted to keep the logical changes minimal and delete them at the same position as before. But yea, accepting this logical change in this case probably makes more sense.

romangg: You can delete a nullptr. But in general yes, the waylandOutput() and waylandOutputDevice()…
85 delete m_cursor[0]; 84​ delete m_cursor[0];
86 delete m_cursor[1]; 85​ delete m_cursor[1];
87} 86​}
88 87​
89void DrmOutput::releaseGbm() 88​void DrmOutput::releaseGbm()
90{ 89​{
91 if (DrmBuffer *b = m_crtc->current()) { 90​ if (DrmBuffer *b = m_crtc->current()) {
92 b->releaseGbm(); 91​ b->releaseGbm();
Show All 29 Lines119{
122 if (cursorImage.isNull()) { 121​ if (cursorImage.isNull()) {
123 return; 122​ return;
124 } 123​ }
125 m_hasNewCursor = true; 124​ m_hasNewCursor = true;
126 QImage *c = m_cursor[m_cursorIndex]->image(); 125​ QImage *c = m_cursor[m_cursorIndex]->image();
127 c->fill(Qt::transparent); 126​ c->fill(Qt::transparent);
128 QPainter p; 127​ QPainter p;
129 p.begin(c); 128​ p.begin(c);
130 if (m_orientation == Qt::InvertedLandscapeOrientation) { 129​ if (orientation() == Qt::InvertedLandscapeOrientation) {
131 QMatrix4x4 matrix; 130​ QMatrix4x4 matrix;
132 matrix.translate(cursorImage.width() / 2.0, cursorImage.height() / 2.0); 131​ matrix.translate(cursorImage.width() / 2.0, cursorImage.height() / 2.0);
133 matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 132​ matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
134 matrix.translate(-cursorImage.width() / 2.0, -cursorImage.height() / 2.0); 133​ matrix.translate(-cursorImage.width() / 2.0, -cursorImage.height() / 2.0);
135 p.setWorldTransform(matrix.toTransform()); 134​ p.setWorldTransform(matrix.toTransform());
136 } 135​ }
137 p.drawImage(QPoint(0, 0), cursorImage); 136​ p.drawImage(QPoint(0, 0), cursorImage);
138 p.end(); 137​ p.end();
139} 138​}
140 139​
141void DrmOutput::moveCursor(const QPoint &globalPos) 140​void DrmOutput::moveCursor(const QPoint &globalPos)
142{ 141​{
143 QMatrix4x4 matrix; 142​ QMatrix4x4 matrix;
144 QMatrix4x4 hotspotMatrix; 143​ QMatrix4x4 hotspotMatrix;
145 if (m_orientation == Qt::InvertedLandscapeOrientation) { 144​ if (orientation() == Qt::InvertedLandscapeOrientation) {
146 matrix.translate(pixelSize().width() /2.0, pixelSize().height() / 2.0); 145​ matrix.translate(pixelSize().width() /2.0, pixelSize().height() / 2.0);
147 matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 146​ matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
148 matrix.translate(-pixelSize().width() /2.0, -pixelSize().height() / 2.0); 147​ matrix.translate(-pixelSize().width() /2.0, -pixelSize().height() / 2.0);
149 const auto cursorSize = m_backend->softwareCursor().size(); 148​ const auto cursorSize = m_backend->softwareCursor().size();
150 hotspotMatrix.translate(cursorSize.width()/2.0, cursorSize.height()/2.0); 149​ hotspotMatrix.translate(cursorSize.width()/2.0, cursorSize.height()/2.0);
151 hotspotMatrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 150​ hotspotMatrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
152 hotspotMatrix.translate(-cursorSize.width()/2.0, -cursorSize.height()/2.0); 151​ hotspotMatrix.translate(-cursorSize.width()/2.0, -cursorSize.height()/2.0);
153 } 152​ }
154 matrix.scale(m_scale); 153​ matrix.scale(scale());
155 matrix.translate(-m_globalPos.x(), -m_globalPos.y()); 154​ auto outputGlobalPos = Output::globalPos();
155​ matrix.translate(-outputGlobalPos.x(), -outputGlobalPos.y());
156 const QPoint p = matrix.map(globalPos) - hotspotMatrix.map(m_backend->softwareCursorHotspot()); 156​ const QPoint p = matrix.map(globalPos) - hotspotMatrix.map(m_backend->softwareCursorHotspot());
157 drmModeMoveCursor(m_backend->fd(), m_crtc->id(), p.x(), p.y()); 157​ drmModeMoveCursor(m_backend->fd(), m_crtc->id(), p.x(), p.y());
158} 158​}
159 159​
160QSize DrmOutput::pixelSize() const 160​QSize DrmOutput::pixelSize() const
161{ 161​{
162 if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) { 162​ auto orient = orientation();
163​ if (orient == Qt::PortraitOrientation || orient == Qt::InvertedPortraitOrientation) {
163 return QSize(m_mode.vdisplay, m_mode.hdisplay); 164​ return QSize(m_mode.vdisplay, m_mode.hdisplay);
164 } 165​ }
165 return QSize(m_mode.hdisplay, m_mode.vdisplay); 166​ return QSize(m_mode.hdisplay, m_mode.vdisplay);
166} 167​}
167 168​
168QSize DrmOutput::physicalSize() const ​
169{ ​
170 if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) { ​
171 return QSize(m_physicalSize.height(), m_physicalSize.width()); ​
172 } ​
173 return m_physicalSize; ​
174} ​
175 ​
176QRect DrmOutput::geometry() const ​
177{ ​
178 return QRect(m_globalPos, pixelSize() / scale()); ​
179} ​
180 ​
181qreal DrmOutput::scale() const ​
182{ ​
183 return m_scale; ​
184} ​
185 ​
186void DrmOutput::setEnabled(bool enabled) 169​void DrmOutput::setEnabled(bool enabled)
187{ 170​{
188 if (enabled == isEnabled()) { 171​ if (enabled == isEnabled()) {
189 return; 172​ return;
190 } 173​ }
191 if (enabled) { 174​ if (enabled) {
192 setDpms(DpmsMode::On); 175​ setDpms(DpmsMode::On);
193 initOutput(); 176​ initOutput();
194 } else { 177​ } else {
195 setDpms(DpmsMode::Off); 178​ setDpms(DpmsMode::Off);
196 delete m_waylandOutput.data(); 179​ delete getWaylandOutput().data();
197 } 180​ }
198 m_waylandOutputDevice->setEnabled(enabled ? 181​ getWaylandOutputDevice()->setEnabled(enabled ?
199 KWayland::Server::OutputDeviceInterface::Enablement::Enabled : KWayland::Server::OutputDeviceInterface::Enablement::Disabled); 182​ KWayland::Server::OutputDeviceInterface::Enablement::Enabled : KWayland::Server::OutputDeviceInterface::Enablement::Disabled);
200} 183​}
201 184​
202bool DrmOutput::isEnabled() const ​
203{ ​
204 return !m_waylandOutput.isNull(); ​
205} ​
206 ​
207static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode) 185​static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
208{ 186​{
209 using namespace KWayland::Server; 187​ using namespace KWayland::Server;
210 switch (mode) { 188​ switch (mode) {
211 case DrmOutput::DpmsMode::On: 189​ case DrmOutput::DpmsMode::On:
212 return OutputInterface::DpmsMode::On; 190​ return OutputInterface::DpmsMode::On;
213 case DrmOutput::DpmsMode::Standby: 191​ case DrmOutput::DpmsMode::Standby:
214 return OutputInterface::DpmsMode::Standby; 192​ return OutputInterface::DpmsMode::Standby;
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Line(s)259{
285 if (m_backend->atomicModeSetting()) { 263​ if (m_backend->atomicModeSetting()) {
286 if (!initPrimaryPlane()) { 264​ if (!initPrimaryPlane()) {
287 return false; 265​ return false;
288 } 266​ }
289 } else if (!m_crtc->blank()) { 267​ } else if (!m_crtc->blank()) {
290 return false; 268​ return false;
291 } 269​ }
292 270​
293 m_internal = connector->connector_type == DRM_MODE_CONNECTOR_LVDS || connector->connector_type == DRM_MODE_CONNECTOR_eDP; 271​ setInternal(connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
272​ connector->connector_type == DRM_MODE_CONNECTOR_eDP);
294 273​
295 if (m_internal) { 274​ if (internal()) {
296 connect(kwinApp(), &Application::screensCreated, this, 275​ connect(kwinApp(), &Application::screensCreated, this,
297 [this] { 276​ [this] {
298 connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation); 277​ connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation);
299 } 278​ }
300 ); 279​ );
301 } 280​ }
302 281​
303 QSize physicalSize = !m_edid.physicalSize.isEmpty() ? m_edid.physicalSize : QSize(connector->mmWidth, connector->mmHeight); 282​ QSize physicalSize = !m_edid.physicalSize.isEmpty() ? m_edid.physicalSize : QSize(connector->mmWidth, connector->mmHeight);
304 // the size might be completely borked. E.g. Samsung SyncMaster 2494HS reports 160x90 while in truth it's 520x292 283​ // the size might be completely borked. E.g. Samsung SyncMaster 2494HS reports 160x90 while in truth it's 520x292
305 // as this information is used to calculate DPI info, it's going to result in everything being huge 284​ // as this information is used to calculate DPI info, it's going to result in everything being huge
306 const QByteArray unknown = QByteArrayLiteral("unknown"); 285​ const QByteArray unknown = QByteArrayLiteral("unknown");
307 KConfigGroup group = kwinApp()->config()->group("EdidOverwrite").group(m_edid.eisaId.isEmpty() ? unknown : m_edid.eisaId) 286​ KConfigGroup group = kwinApp()->config()->group("EdidOverwrite").group(m_edid.eisaId.isEmpty() ? unknown : m_edid.eisaId)
308 .group(m_edid.monitorName.isEmpty() ? unknown : m_edid.monitorName) 287​ .group(m_edid.monitorName.isEmpty() ? unknown : m_edid.monitorName)
309 .group(m_edid.serialNumber.isEmpty() ? unknown : m_edid.serialNumber); 288​ .group(m_edid.serialNumber.isEmpty() ? unknown : m_edid.serialNumber);
310 if (group.hasKey("PhysicalSize")) { 289​ if (group.hasKey("PhysicalSize")) {
311 const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize); 290​ const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize);
312 qCWarning(KWIN_DRM) << "Overwriting monitor physical size for" << m_edid.eisaId << "/" << m_edid.monitorName << "/" << m_edid.serialNumber << " from " << physicalSize << "to " << overwriteSize; 291​ qCWarning(KWIN_DRM) << "Overwriting monitor physical size for" << m_edid.eisaId << "/" << m_edid.monitorName << "/" << m_edid.serialNumber << " from " << physicalSize << "to " << overwriteSize;
313 physicalSize = overwriteSize; 292​ physicalSize = overwriteSize;
314 } 293​ }
315 m_physicalSize = physicalSize; 294​ setRawPhysicalSize(physicalSize);
316 295​
317 initOutputDevice(connector); 296​ initOutputDevice(connector);
318 297​
319 setEnabled(true); 298​ setEnabled(true);
320 return true; 299​ return true;
321} 300​}
322 301​
323void DrmOutput::initUuid() 302​void DrmOutput::initUuid()
324{ 303​{
325 QCryptographicHash hash(QCryptographicHash::Md5); 304​ QCryptographicHash hash(QCryptographicHash::Md5);
326 hash.addData(QByteArray::number(m_conn->id())); 305​ hash.addData(QByteArray::number(m_conn->id()));
327 hash.addData(m_edid.eisaId); 306​ hash.addData(m_edid.eisaId);
328 hash.addData(m_edid.monitorName); 307​ hash.addData(m_edid.monitorName);
329 hash.addData(m_edid.serialNumber); 308​ hash.addData(m_edid.serialNumber);
330 m_uuid = hash.result().toHex().left(10); 309​ m_uuid = hash.result().toHex().left(10);
331} 310​}
332 311​
333void DrmOutput::initOutput() 312​void DrmOutput::initOutput()
334{ 313​{
335 Q_ASSERT(m_waylandOutputDevice); 314​ auto waylandOutputDevice = getWaylandOutputDevice();
336 if (!m_waylandOutput.isNull()) { 315​ Q_ASSERT(waylandOutputDevice);
337 delete m_waylandOutput.data(); 316​
338 m_waylandOutput.clear(); 317​ auto waylandOutput = getWaylandOutput();
318​ if (!waylandOutput.isNull()) {
319​ delete waylandOutput.data();
320​ waylandOutput.clear();
339 } 321​ }
340 m_waylandOutput = waylandServer()->display()->createOutput(); 322​ waylandOutput = waylandServer()->display()->createOutput();
341 connect(this, &DrmOutput::modeChanged, this, 323​ connect(this, &DrmOutput::modeChanged, this,
342 [this] { 324​ [this] {
343 if (m_waylandOutput.isNull()) { 325​ auto waylandOutput = getWaylandOutput();
326​ if (waylandOutput.isNull()) {
344 return; 327​ return;
345 } 328​ }
346 m_waylandOutput->setCurrentMode(QSize(m_mode.hdisplay, m_mode.vdisplay), refreshRateForMode(&m_mode)); 329​ waylandOutput->setCurrentMode(QSize(m_mode.hdisplay, m_mode.vdisplay),
330​ refreshRateForMode(&m_mode));
347 } 331​ }
348 ); 332​ );
349 m_waylandOutput->setManufacturer(m_waylandOutputDevice->manufacturer()); 333​ waylandOutput->setManufacturer(waylandOutputDevice->manufacturer());
350 m_waylandOutput->setModel(m_waylandOutputDevice->model()); 334​ waylandOutput->setModel(waylandOutputDevice->model());
351 m_waylandOutput->setPhysicalSize(m_physicalSize); 335​ waylandOutput->setPhysicalSize(rawPhysicalSize());
352 336​
353 // set dpms 337​ // set dpms
354 if (!m_dpms.isNull()) { 338​ if (!m_dpms.isNull()) {
355 m_waylandOutput->setDpmsSupported(true); 339​ waylandOutput->setDpmsSupported(true);
356 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode)); 340​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode));
357 connect(m_waylandOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this, 341​ connect(waylandOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this,
358 [this] (KWayland::Server::OutputInterface::DpmsMode mode) { 342​ [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
359 setDpms(fromWaylandDpmsMode(mode)); 343​ setDpms(fromWaylandDpmsMode(mode));
360 }, Qt::QueuedConnection 344​ }, Qt::QueuedConnection
361 ); 345​ );
362 } 346​ }
363 347​
364 for(const auto &mode: m_waylandOutputDevice->modes()) { 348​ for(const auto &mode: waylandOutputDevice->modes()) {
365 KWayland::Server::OutputInterface::ModeFlags flags; 349​ KWayland::Server::OutputInterface::ModeFlags flags;
366 if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Current) { 350​ if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Current) {
367 flags |= KWayland::Server::OutputInterface::ModeFlag::Current; 351​ flags |= KWayland::Server::OutputInterface::ModeFlag::Current;
368 } 352​ }
369 if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred) { 353​ if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred) {
370 flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred; 354​ flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred;
371 } 355​ }
372 m_waylandOutput->addMode(mode.size, flags, mode.refreshRate); 356​ waylandOutput->addMode(mode.size, flags, mode.refreshRate);
373 } 357​ }
374 358​
375 m_waylandOutput->create(); 359​ waylandOutput->create();
360​ setWaylandOutput(waylandOutput.data());
376} 361​}
377 362​
378void DrmOutput::initOutputDevice(drmModeConnector *connector) 363​void DrmOutput::initOutputDevice(drmModeConnector *connector)
379{ 364​{
380 if (!m_waylandOutputDevice.isNull()) { 365​ auto waylandOutputDevice = getWaylandOutputDevice();
381 delete m_waylandOutputDevice.data(); 366​ if (!waylandOutputDevice.isNull()) {
382 m_waylandOutputDevice.clear(); 367​ delete waylandOutputDevice.data();
368​ waylandOutputDevice.clear();
383 } 369​ }
384 m_waylandOutputDevice = waylandServer()->display()->createOutputDevice(); 370​ waylandOutputDevice = waylandServer()->display()->createOutputDevice();
385 m_waylandOutputDevice->setUuid(m_uuid); 371​ waylandOutputDevice->setUuid(m_uuid);
386 372​
387 if (!m_edid.eisaId.isEmpty()) { 373​ if (!m_edid.eisaId.isEmpty()) {
388 m_waylandOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId)); 374​ waylandOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId));
389 } else { 375​ } else {
390 m_waylandOutputDevice->setManufacturer(i18n("unknown")); 376​ waylandOutputDevice->setManufacturer(i18n("unknown"));
391 } 377​ }
392 378​
393 QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown")); 379​ QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown"));
394 QString modelName; 380​ QString modelName;
395 381​
396 if (!m_edid.monitorName.isEmpty()) { 382​ if (!m_edid.monitorName.isEmpty()) {
397 QString model = QString::fromLatin1(m_edid.monitorName); 383​ QString model = QString::fromLatin1(m_edid.monitorName);
398 if (!m_edid.serialNumber.isEmpty()) { 384​ if (!m_edid.serialNumber.isEmpty()) {
399 model.append('/'); 385​ model.append('/');
400 model.append(QString::fromLatin1(m_edid.serialNumber)); 386​ model.append(QString::fromLatin1(m_edid.serialNumber));
401 } 387​ }
402 modelName = model; 388​ modelName = model;
403 } else if (!m_edid.serialNumber.isEmpty()) { 389​ } else if (!m_edid.serialNumber.isEmpty()) {
404 modelName = QString::fromLatin1(m_edid.serialNumber); 390​ modelName = QString::fromLatin1(m_edid.serialNumber);
405 } else { 391​ } else {
406 modelName = i18n("unknown"); 392​ modelName = i18n("unknown");
407 } 393​ }
408 394​
409 m_waylandOutputDevice->setModel(connectorName + QStringLiteral("-") + QString::number(connector->connector_type_id) + QStringLiteral("-") + modelName); 395​ waylandOutputDevice->setModel(connectorName + QStringLiteral("-") + QString::number(connector->connector_type_id) + QStringLiteral("-") + modelName);
410 396​
411 m_waylandOutputDevice->setPhysicalSize(m_physicalSize); 397​ waylandOutputDevice->setPhysicalSize(rawPhysicalSize());
412 398​
413 // read in mode information 399​ // read in mode information
414 for (int i = 0; i < connector->count_modes; ++i) { 400​ for (int i = 0; i < connector->count_modes; ++i) {
415 // TODO: in AMS here we could read and store for later every mode's blob_id 401​ // TODO: in AMS here we could read and store for later every mode's blob_id
416 // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set 402​ // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set
417 auto *m = &connector->modes[i]; 403​ auto *m = &connector->modes[i];
418 KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags; 404​ KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags;
419 if (isCurrentMode(m)) { 405​ if (isCurrentMode(m)) {
420 deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current; 406​ deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
421 } 407​ }
422 if (m->type & DRM_MODE_TYPE_PREFERRED) { 408​ if (m->type & DRM_MODE_TYPE_PREFERRED) {
423 deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred; 409​ deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred;
424 } 410​ }
425 411​
426 const auto refreshRate = refreshRateForMode(m); 412​ const auto refreshRate = refreshRateForMode(m);
427 413​
428 KWayland::Server::OutputDeviceInterface::Mode mode; 414​ KWayland::Server::OutputDeviceInterface::Mode mode;
429 mode.id = i; 415​ mode.id = i;
430 mode.size = QSize(m->hdisplay, m->vdisplay); 416​ mode.size = QSize(m->hdisplay, m->vdisplay);
431 mode.flags = deviceflags; 417​ mode.flags = deviceflags;
432 mode.refreshRate = refreshRate; 418​ mode.refreshRate = refreshRate;
433 qCDebug(KWIN_DRM) << "Adding mode: " << i << mode.size; 419​ qCDebug(KWIN_DRM) << "Adding mode: " << i << mode.size;
434 m_waylandOutputDevice->addMode(mode); 420​ waylandOutputDevice->addMode(mode);
435 } 421​ }
436 m_waylandOutputDevice->create(); 422​ waylandOutputDevice->create();
423​ setWaylandOutputDevice(waylandOutputDevice.data());
437} 424​}
438 425​
439bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const 426​bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const
440{ 427​{
441 return mode->clock == m_mode.clock 428​ return mode->clock == m_mode.clock
442 && mode->hdisplay == m_mode.hdisplay 429​ && mode->hdisplay == m_mode.hdisplay
443 && mode->hsync_start == m_mode.hsync_start 430​ && mode->hsync_start == m_mode.hsync_start
444 && mode->hsync_end == m_mode.hsync_end 431​ && mode->hsync_end == m_mode.hsync_end
▲ Show 20 Lines • Show All 278 Lines • ▼ Show 20 Line(s)699 } else {
723 m_dpmsMode = m_dpmsModePending; 710​ m_dpmsMode = m_dpmsModePending;
724 } 711​ }
725} 712​}
726 713​
727void DrmOutput::dpmsOnHandler() 714​void DrmOutput::dpmsOnHandler()
728{ 715​{
729 qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to On."; 716​ qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to On.";
730 717​
731 if (m_waylandOutput) { 718​ auto waylandOutput = getWaylandOutput();
732 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending)); 719​ if (waylandOutput) {
720​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
733 } 721​ }
734 emit dpmsChanged(); 722​ emit dpmsChanged();
735 723​
736 m_backend->checkOutputsAreOn(); 724​ m_backend->checkOutputsAreOn();
737 if (!m_backend->atomicModeSetting()) { 725​ if (!m_backend->atomicModeSetting()) {
738 m_crtc->blank(); 726​ m_crtc->blank();
739 } 727​ }
740 if (Compositor *compositor = Compositor::self()) { 728​ if (Compositor *compositor = Compositor::self()) {
741 compositor->addRepaintFull(); 729​ compositor->addRepaintFull();
742 } 730​ }
743} 731​}
744 732​
745void DrmOutput::dpmsOffHandler() 733​void DrmOutput::dpmsOffHandler()
746{ 734​{
747 qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to Off."; 735​ qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to Off.";
748 736​
749 if (m_waylandOutput) { 737​ auto waylandOutput = getWaylandOutput();
750 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending)); 738​ if (waylandOutput) {
739​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
751 } 740​ }
752 emit dpmsChanged(); 741​ emit dpmsChanged();
753 742​
754 m_backend->outputWentOff(); 743​ m_backend->outputWentOff();
755} 744​}
756 745​
757QString DrmOutput::name() const ​
758{ ​
759 if (!m_waylandOutput) { ​
760 return i18n("unknown"); ​
761 } ​
762 return QStringLiteral("%1 %2").arg(m_waylandOutput->manufacturer()).arg(m_waylandOutput->model()); ​
763} ​
764 ​
765int DrmOutput::currentRefreshRate() const 746​int DrmOutput::currentRefreshRate() const
766{ 747​{
767 if (!m_waylandOutput) { 748​ auto waylandOutput = getWaylandOutput();
749​ if (!waylandOutput) {
768 return 60000; 750​ return 60000;
769 } 751​ }
770 return m_waylandOutput->refreshRate(); 752​ return waylandOutput->refreshRate();
771} ​
772 ​
773void DrmOutput::setGlobalPos(const QPoint &pos) ​
774{ ​
775 m_globalPos = pos; ​
776 if (m_waylandOutput) { ​
777 m_waylandOutput->setGlobalPosition(pos); ​
778 } ​
779 if (m_waylandOutputDevice) { ​
780 m_waylandOutputDevice->setGlobalPosition(pos); ​
781 } ​
782} ​
783 ​
784void DrmOutput::setScale(qreal scale) ​
785{ ​
786 m_scale = scale; ​
787 if (m_waylandOutput) { ​
788 m_waylandOutput->setScale(scale); ​
789 } ​
790 if (m_waylandOutputDevice) { ​
791 m_waylandOutputDevice->setScale(scale); ​
792 } ​
793} ​
794 ​
795void DrmOutput::setChanges(KWayland::Server::OutputChangeSet *changes) ​
796{ ​
797 m_changeset = changes; ​
798 qCDebug(KWIN_DRM) << "set changes in DrmOutput"; ​
799 commitChanges(); ​
800} 753​}
801 754​
802bool DrmOutput::commitChanges() 755​bool DrmOutput::commitChanges()
803{ 756​{
804 Q_ASSERT(!m_waylandOutputDevice.isNull()); 757​ auto waylandOutputDevice = getWaylandOutputDevice();
758​ Q_ASSERT(!waylandOutputDevice.isNull());
805 759​
806 if (m_changeset.isNull()) { 760​ auto changeset = getChangeset();
761​
762​ if (changeset.isNull()) {
807 qCDebug(KWIN_DRM) << "no changes"; 763​ qCDebug(KWIN_DRM) << "no changes";
808 // No changes to an output is an entirely valid thing 764​ // No changes to an output is an entirely valid thing
809 return true; 765​ return true;
810 } 766​ }
811 //enabledChanged is handled by drmbackend 767​ //enabledChanged is handled by drmbackend
812 if (m_changeset->modeChanged()) { 768​ if (changeset->modeChanged()) {
813 qCDebug(KWIN_DRM) << "Setting new mode:" << m_changeset->mode(); 769​ qCDebug(KWIN_DRM) << "Setting new mode:" << changeset->mode();
814 m_waylandOutputDevice->setCurrentMode(m_changeset->mode()); 770​ waylandOutputDevice->setCurrentMode(changeset->mode());
815 updateMode(m_changeset->mode()); 771​ updateMode(changeset->mode());
816 } 772​ }
817 if (m_changeset->transformChanged()) { 773​ if (changeset->transformChanged()) {
818 qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(m_changeset->transform()); 774​ qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(changeset->transform());
819 transform(m_changeset->transform()); 775​ transform(changeset->transform());
820 } 776​ }
821 if (m_changeset->positionChanged()) { 777​ if (changeset->positionChanged()) {
822 qCDebug(KWIN_DRM) << "Server setting position: " << m_changeset->position(); 778​ qCDebug(KWIN_DRM) << "Server setting position: " << changeset->position();
823 setGlobalPos(m_changeset->position()); 779​ setGlobalPos(changeset->position());
824 // may just work already! 780​ // may just work already!
825 } 781​ }
826 if (m_changeset->scaleChanged()) { 782​ if (changeset->scaleChanged()) {
827 qCDebug(KWIN_DRM) << "Setting scale:" << m_changeset->scale(); 783​ qCDebug(KWIN_DRM) << "Setting scale:" << changeset->scale();
828 setScale(m_changeset->scale()); 784​ setScale(changeset->scale());
829 } 785​ }
830 return true; 786​ return true;
831} 787​}
832 788​
833void DrmOutput::transform(KWayland::Server::OutputDeviceInterface::Transform transform) 789​void DrmOutput::transform(KWayland::Server::OutputDeviceInterface::Transform transform)
834{ 790​{
835 m_waylandOutputDevice->setTransform(transform); 791​ getWaylandOutputDevice()->setTransform(transform);
836 using KWayland::Server::OutputDeviceInterface; 792​ using KWayland::Server::OutputDeviceInterface;
837 using KWayland::Server::OutputInterface; 793​ using KWayland::Server::OutputInterface;
794​ auto waylandOutput = getWaylandOutput();
795​
838 switch (transform) { 796​ switch (transform) {
839 case OutputDeviceInterface::Transform::Normal: 797​ case OutputDeviceInterface::Transform::Normal:
840 if (m_primaryPlane) { 798​ if (m_primaryPlane) {
841 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0); 799​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0);
842 } 800​ }
843 if (m_waylandOutput) { 801​ if (waylandOutput) {
844 m_waylandOutput->setTransform(OutputInterface::Transform::Normal); 802​ waylandOutput->setTransform(OutputInterface::Transform::Normal);
845 } 803​ }
846 m_orientation = Qt::PrimaryOrientation; 804​ setOrientation(Qt::PrimaryOrientation);
847 break; 805​ break;
848 case OutputDeviceInterface::Transform::Rotated90: 806​ case OutputDeviceInterface::Transform::Rotated90:
849 if (m_primaryPlane) { 807​ if (m_primaryPlane) {
850 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate90); 808​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate90);
851 } 809​ }
852 if (m_waylandOutput) { 810​ if (waylandOutput) {
853 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated90); 811​ waylandOutput->setTransform(OutputInterface::Transform::Rotated90);
854 } 812​ }
855 m_orientation = Qt::PortraitOrientation; 813​ setOrientation(Qt::PortraitOrientation);
856 break; 814​ break;
857 case OutputDeviceInterface::Transform::Rotated180: 815​ case OutputDeviceInterface::Transform::Rotated180:
858 if (m_primaryPlane) { 816​ if (m_primaryPlane) {
859 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate180); 817​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate180);
860 } 818​ }
861 if (m_waylandOutput) { 819​ if (waylandOutput) {
862 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated180); 820​ waylandOutput->setTransform(OutputInterface::Transform::Rotated180);
863 } 821​ }
864 m_orientation = Qt::InvertedLandscapeOrientation; 822​ setOrientation(Qt::InvertedLandscapeOrientation);
865 break; 823​ break;
866 case OutputDeviceInterface::Transform::Rotated270: 824​ case OutputDeviceInterface::Transform::Rotated270:
867 if (m_primaryPlane) { 825​ if (m_primaryPlane) {
868 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate270); 826​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate270);
869 } 827​ }
870 if (m_waylandOutput) { 828​ if (waylandOutput) {
871 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated270); 829​ waylandOutput->setTransform(OutputInterface::Transform::Rotated270);
872 } 830​ }
873 m_orientation = Qt::InvertedPortraitOrientation; 831​ setOrientation(Qt::InvertedPortraitOrientation);
874 break; 832​ break;
875 case OutputDeviceInterface::Transform::Flipped: 833​ case OutputDeviceInterface::Transform::Flipped:
876 // TODO: what is this exactly? 834​ // TODO: what is this exactly?
877 if (m_waylandOutput) { 835​ if (waylandOutput) {
878 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped); 836​ waylandOutput->setTransform(OutputInterface::Transform::Flipped);
879 } 837​ }
880 break; 838​ break;
881 case OutputDeviceInterface::Transform::Flipped90: 839​ case OutputDeviceInterface::Transform::Flipped90:
882 // TODO: what is this exactly? 840​ // TODO: what is this exactly?
883 if (m_waylandOutput) { 841​ if (waylandOutput) {
884 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped90); 842​ waylandOutput->setTransform(OutputInterface::Transform::Flipped90);
885 } 843​ }
886 break; 844​ break;
887 case OutputDeviceInterface::Transform::Flipped180: 845​ case OutputDeviceInterface::Transform::Flipped180:
888 // TODO: what is this exactly? 846​ // TODO: what is this exactly?
889 if (m_waylandOutput) { 847​ if (waylandOutput) {
890 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped180); 848​ waylandOutput->setTransform(OutputInterface::Transform::Flipped180);
891 } 849​ }
892 break; 850​ break;
893 case OutputDeviceInterface::Transform::Flipped270: 851​ case OutputDeviceInterface::Transform::Flipped270:
894 // TODO: what is this exactly? 852​ // TODO: what is this exactly?
895 if (m_waylandOutput) { 853​ if (waylandOutput) {
896 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped270); 854​ waylandOutput->setTransform(OutputInterface::Transform::Flipped270);
897 } 855​ }
898 break; 856​ break;
899 } 857​ }
900 m_modesetRequested = true; 858​ m_modesetRequested = true;
901 // the cursor might need to get rotated 859​ // the cursor might need to get rotated
902 updateCursor(); 860​ updateCursor();
903 showCursor(); 861​ showCursor();
904 emit modeChanged(); 862​ emit modeChanged();
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Line(s)963{
1018 976​
1019 if (!doAtomicCommit(AtomicCommitMode::Test)) { 977​ if (!doAtomicCommit(AtomicCommitMode::Test)) {
1020 //TODO: When we use planes for layered rendering, fallback to renderer instead. Also for direct scanout? 978​ //TODO: When we use planes for layered rendering, fallback to renderer instead. Also for direct scanout?
1021 //TODO: Probably should undo setNext and reset the flip list 979​ //TODO: Probably should undo setNext and reset the flip list
1022 qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present."; 980​ qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present.";
1023 // go back to previous state 981​ // go back to previous state
1024 if (m_lastWorkingState.valid) { 982​ if (m_lastWorkingState.valid) {
1025 m_mode = m_lastWorkingState.mode; 983​ m_mode = m_lastWorkingState.mode;
1026 m_orientation = m_lastWorkingState.orientation; 984​ setOrientation(m_lastWorkingState.orientation);
1027 setGlobalPos(m_lastWorkingState.globalPos); 985​ setGlobalPos(m_lastWorkingState.globalPos);
1028 if (m_primaryPlane) { 986​ if (m_primaryPlane) {
1029 m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations); 987​ m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations);
1030 } 988​ }
1031 m_modesetRequested = true; 989​ m_modesetRequested = true;
1032 // the cursor might need to get rotated 990​ // the cursor might need to get rotated
1033 updateCursor(); 991​ updateCursor();
1034 showCursor(); 992​ showCursor();
1035 // TODO: forward to OutputInterface and OutputDeviceInterface 993​ // TODO: forward to OutputInterface and OutputDeviceInterface
1036 emit modeChanged(); 994​ emit modeChanged();
1037 emit screens()->changed(); 995​ emit screens()->changed();
1038 } 996​ }
1039 return false; 997​ return false;
1040 } 998​ }
1041 const bool wasModeset = m_modesetRequested; 999​ const bool wasModeset = m_modesetRequested;
1042 if (!doAtomicCommit(AtomicCommitMode::Real)) { 1000​ if (!doAtomicCommit(AtomicCommitMode::Real)) {
1043 qCDebug(KWIN_DRM) << "Atomic commit failed. This should have never happened! Aborting present."; 1001​ qCDebug(KWIN_DRM) << "Atomic commit failed. This should have never happened! Aborting present.";
1044 //TODO: Probably should undo setNext and reset the flip list 1002​ //TODO: Probably should undo setNext and reset the flip list
1045 return false; 1003​ return false;
1046 } 1004​ }
1047 if (wasModeset) { 1005​ if (wasModeset) {
1048 // store current mode set as new good state 1006​ // store current mode set as new good state
1049 m_lastWorkingState.mode = m_mode; 1007​ m_lastWorkingState.mode = m_mode;
1050 m_lastWorkingState.orientation = m_orientation; 1008​ m_lastWorkingState.orientation = orientation();
1051 m_lastWorkingState.globalPos = m_globalPos; 1009​ m_lastWorkingState.globalPos = globalPos();
1052 if (m_primaryPlane) { 1010​ if (m_primaryPlane) {
1053 m_lastWorkingState.planeTransformations = m_primaryPlane->transformation(); 1011​ m_lastWorkingState.planeTransformations = m_primaryPlane->transformation();
1054 } 1012​ }
1055 m_lastWorkingState.valid = true; 1013​ m_lastWorkingState.valid = true;
1056 } 1014​ }
1057 m_pageFlipPending = true; 1015​ m_pageFlipPending = true;
1058 return true; 1016​ return true;
1059} 1017​}
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines