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