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

Changeset View

Standalone View

View Options

plugins/platforms/drm/drm_output.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Line(s)73 if (m_backend->deleteBufferAfterPageFlip()) {
74 delete m_primaryPlane->current(); 74​ delete m_primaryPlane->current();
75 } 75​ }
76 m_primaryPlane->setCurrent(nullptr); 76​ m_primaryPlane->setCurrent(nullptr);
77 } 77​ }
78 78​
79 m_crtc->setOutput(nullptr); 79​ m_crtc->setOutput(nullptr);
80 m_conn->setOutput(nullptr); 80​ m_conn->setOutput(nullptr);
81 81​
82 delete m_waylandOutput.data(); 82​ delete getWaylandOutput().data();
83 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()…
84 delete m_cursor[0]; 84​ delete m_cursor[0];
85 delete m_cursor[1]; 85​ delete m_cursor[1];
86} 86​}
87 87​
88void DrmOutput::releaseGbm() 88​void DrmOutput::releaseGbm()
89{ 89​{
90 if (DrmBuffer *b = m_crtc->current()) { 90​ if (DrmBuffer *b = m_crtc->current()) {
91 b->releaseGbm(); 91​ b->releaseGbm();
Show All 29 Lines119{
121 if (cursorImage.isNull()) { 121​ if (cursorImage.isNull()) {
122 return; 122​ return;
123 } 123​ }
124 m_hasNewCursor = true; 124​ m_hasNewCursor = true;
125 QImage *c = m_cursor[m_cursorIndex]->image(); 125​ QImage *c = m_cursor[m_cursorIndex]->image();
126 c->fill(Qt::transparent); 126​ c->fill(Qt::transparent);
127 QPainter p; 127​ QPainter p;
128 p.begin(c); 128​ p.begin(c);
129 if (m_orientation == Qt::InvertedLandscapeOrientation) { 129​ if (orientation() == Qt::InvertedLandscapeOrientation) {
130 QMatrix4x4 matrix; 130​ QMatrix4x4 matrix;
131 matrix.translate(cursorImage.width() / 2.0, cursorImage.height() / 2.0); 131​ matrix.translate(cursorImage.width() / 2.0, cursorImage.height() / 2.0);
132 matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 132​ matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
133 matrix.translate(-cursorImage.width() / 2.0, -cursorImage.height() / 2.0); 133​ matrix.translate(-cursorImage.width() / 2.0, -cursorImage.height() / 2.0);
134 p.setWorldTransform(matrix.toTransform()); 134​ p.setWorldTransform(matrix.toTransform());
135 } 135​ }
136 p.drawImage(QPoint(0, 0), cursorImage); 136​ p.drawImage(QPoint(0, 0), cursorImage);
137 p.end(); 137​ p.end();
138} 138​}
139 139​
140void DrmOutput::moveCursor(const QPoint &globalPos) 140​void DrmOutput::moveCursor(const QPoint &globalPos)
141{ 141​{
142 QMatrix4x4 matrix; 142​ QMatrix4x4 matrix;
143 QMatrix4x4 hotspotMatrix; 143​ QMatrix4x4 hotspotMatrix;
144 if (m_orientation == Qt::InvertedLandscapeOrientation) { 144​ if (orientation() == Qt::InvertedLandscapeOrientation) {
145 matrix.translate(pixelSize().width() /2.0, pixelSize().height() / 2.0); 145​ matrix.translate(pixelSize().width() /2.0, pixelSize().height() / 2.0);
146 matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 146​ matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
147 matrix.translate(-pixelSize().width() /2.0, -pixelSize().height() / 2.0); 147​ matrix.translate(-pixelSize().width() /2.0, -pixelSize().height() / 2.0);
148 const auto cursorSize = m_backend->softwareCursor().size(); 148​ const auto cursorSize = m_backend->softwareCursor().size();
149 hotspotMatrix.translate(cursorSize.width()/2.0, cursorSize.height()/2.0); 149​ hotspotMatrix.translate(cursorSize.width()/2.0, cursorSize.height()/2.0);
150 hotspotMatrix.rotate(180.0f, 0.0f, 0.0f, 1.0f); 150​ hotspotMatrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
151 hotspotMatrix.translate(-cursorSize.width()/2.0, -cursorSize.height()/2.0); 151​ hotspotMatrix.translate(-cursorSize.width()/2.0, -cursorSize.height()/2.0);
152 } 152​ }
153 matrix.scale(m_scale); 153​ matrix.scale(scale());
154 matrix.translate(-m_globalPos.x(), -m_globalPos.y()); 154​ auto outputGlobalPos = Output::globalPos();
155​ matrix.translate(-outputGlobalPos.x(), -outputGlobalPos.y());
155 const QPoint p = matrix.map(globalPos) - hotspotMatrix.map(m_backend->softwareCursorHotspot()); 156​ const QPoint p = matrix.map(globalPos) - hotspotMatrix.map(m_backend->softwareCursorHotspot());
156 drmModeMoveCursor(m_backend->fd(), m_crtc->id(), p.x(), p.y()); 157​ drmModeMoveCursor(m_backend->fd(), m_crtc->id(), p.x(), p.y());
157} 158​}
158 159​
159QSize DrmOutput::pixelSize() const 160​QSize DrmOutput::pixelSize() const
160{ 161​{
161 if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) { 162​ auto orient = orientation();
163​ if (orient == Qt::PortraitOrientation || orient == Qt::InvertedPortraitOrientation) {
162 return QSize(m_mode.vdisplay, m_mode.hdisplay); 164​ return QSize(m_mode.vdisplay, m_mode.hdisplay);
163 } 165​ }
164 return QSize(m_mode.hdisplay, m_mode.vdisplay); 166​ return QSize(m_mode.hdisplay, m_mode.vdisplay);
165} 167​}
166 168​
167void DrmOutput::setEnabled(bool enabled) 169​void DrmOutput::setEnabled(bool enabled)
168{ 170​{
169 if (enabled == isEnabled()) { 171​ if (enabled == isEnabled()) {
170 return; 172​ return;
171 } 173​ }
172 if (enabled) { 174​ if (enabled) {
173 setDpms(DpmsMode::On); 175​ setDpms(DpmsMode::On);
174 initOutput(); 176​ initOutput();
175 } else { 177​ } else {
176 setDpms(DpmsMode::Off); 178​ setDpms(DpmsMode::Off);
177 delete m_waylandOutput.data(); 179​ delete getWaylandOutput().data();
178 } 180​ }
179 m_waylandOutputDevice->setEnabled(enabled ? 181​ getWaylandOutputDevice()->setEnabled(enabled ?
180 KWayland::Server::OutputDeviceInterface::Enablement::Enabled : KWayland::Server::OutputDeviceInterface::Enablement::Disabled); 182​ KWayland::Server::OutputDeviceInterface::Enablement::Enabled : KWayland::Server::OutputDeviceInterface::Enablement::Disabled);
181} 183​}
182 184​
183static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode) 185​static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
184{ 186​{
185 using namespace KWayland::Server; 187​ using namespace KWayland::Server;
186 switch (mode) { 188​ switch (mode) {
187 case DrmOutput::DpmsMode::On: 189​ case DrmOutput::DpmsMode::On:
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Line(s)259{
261 if (m_backend->atomicModeSetting()) { 263​ if (m_backend->atomicModeSetting()) {
262 if (!initPrimaryPlane()) { 264​ if (!initPrimaryPlane()) {
263 return false; 265​ return false;
264 } 266​ }
265 } else if (!m_crtc->blank()) { 267​ } else if (!m_crtc->blank()) {
266 return false; 268​ return false;
267 } 269​ }
268 270​
269 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);
270 273​
271 if (m_internal) { 274​ if (internal()) {
272 connect(kwinApp(), &Application::screensCreated, this, 275​ connect(kwinApp(), &Application::screensCreated, this,
273 [this] { 276​ [this] {
274 connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation); 277​ connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation);
275 } 278​ }
276 ); 279​ );
277 } 280​ }
278 281​
279 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);
280 // 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
281 // 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
282 const QByteArray unknown = QByteArrayLiteral("unknown"); 285​ const QByteArray unknown = QByteArrayLiteral("unknown");
283 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)
284 .group(m_edid.monitorName.isEmpty() ? unknown : m_edid.monitorName) 287​ .group(m_edid.monitorName.isEmpty() ? unknown : m_edid.monitorName)
285 .group(m_edid.serialNumber.isEmpty() ? unknown : m_edid.serialNumber); 288​ .group(m_edid.serialNumber.isEmpty() ? unknown : m_edid.serialNumber);
286 if (group.hasKey("PhysicalSize")) { 289​ if (group.hasKey("PhysicalSize")) {
287 const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize); 290​ const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize);
288 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;
289 physicalSize = overwriteSize; 292​ physicalSize = overwriteSize;
290 } 293​ }
291 m_physicalSize = physicalSize; 294​ setRawPhysicalSize(physicalSize);
292 295​
293 initOutputDevice(connector); 296​ initOutputDevice(connector);
294 297​
295 setEnabled(true); 298​ setEnabled(true);
296 return true; 299​ return true;
297} 300​}
298 301​
299void DrmOutput::initUuid() 302​void DrmOutput::initUuid()
300{ 303​{
301 QCryptographicHash hash(QCryptographicHash::Md5); 304​ QCryptographicHash hash(QCryptographicHash::Md5);
302 hash.addData(QByteArray::number(m_conn->id())); 305​ hash.addData(QByteArray::number(m_conn->id()));
303 hash.addData(m_edid.eisaId); 306​ hash.addData(m_edid.eisaId);
304 hash.addData(m_edid.monitorName); 307​ hash.addData(m_edid.monitorName);
305 hash.addData(m_edid.serialNumber); 308​ hash.addData(m_edid.serialNumber);
306 m_uuid = hash.result().toHex().left(10); 309​ m_uuid = hash.result().toHex().left(10);
307} 310​}
308 311​
309void DrmOutput::initOutput() 312​void DrmOutput::initOutput()
310{ 313​{
311 Q_ASSERT(m_waylandOutputDevice); 314​ auto waylandOutputDevice = getWaylandOutputDevice();
312 if (!m_waylandOutput.isNull()) { 315​ Q_ASSERT(waylandOutputDevice);
313 delete m_waylandOutput.data(); 316​
314 m_waylandOutput.clear(); 317​ auto waylandOutput = getWaylandOutput();
318​ if (!waylandOutput.isNull()) {
319​ delete waylandOutput.data();
320​ waylandOutput.clear();
315 } 321​ }
316 m_waylandOutput = waylandServer()->display()->createOutput(); 322​ waylandOutput = waylandServer()->display()->createOutput();
317 connect(this, &DrmOutput::modeChanged, this, 323​ connect(this, &DrmOutput::modeChanged, this,
318 [this] { 324​ [this] {
319 if (m_waylandOutput.isNull()) { 325​ auto waylandOutput = getWaylandOutput();
326​ if (waylandOutput.isNull()) {
320 return; 327​ return;
321 } 328​ }
322 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));
323 } 331​ }
324 ); 332​ );
325 m_waylandOutput->setManufacturer(m_waylandOutputDevice->manufacturer()); 333​ waylandOutput->setManufacturer(waylandOutputDevice->manufacturer());
326 m_waylandOutput->setModel(m_waylandOutputDevice->model()); 334​ waylandOutput->setModel(waylandOutputDevice->model());
327 m_waylandOutput->setPhysicalSize(m_physicalSize); 335​ waylandOutput->setPhysicalSize(rawPhysicalSize());
328 336​
329 // set dpms 337​ // set dpms
330 if (!m_dpms.isNull()) { 338​ if (!m_dpms.isNull()) {
331 m_waylandOutput->setDpmsSupported(true); 339​ waylandOutput->setDpmsSupported(true);
332 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode)); 340​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode));
333 connect(m_waylandOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this, 341​ connect(waylandOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this,
334 [this] (KWayland::Server::OutputInterface::DpmsMode mode) { 342​ [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
335 setDpms(fromWaylandDpmsMode(mode)); 343​ setDpms(fromWaylandDpmsMode(mode));
336 }, Qt::QueuedConnection 344​ }, Qt::QueuedConnection
337 ); 345​ );
338 } 346​ }
339 347​
340 for(const auto &mode: m_waylandOutputDevice->modes()) { 348​ for(const auto &mode: waylandOutputDevice->modes()) {
341 KWayland::Server::OutputInterface::ModeFlags flags; 349​ KWayland::Server::OutputInterface::ModeFlags flags;
342 if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Current) { 350​ if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Current) {
343 flags |= KWayland::Server::OutputInterface::ModeFlag::Current; 351​ flags |= KWayland::Server::OutputInterface::ModeFlag::Current;
344 } 352​ }
345 if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred) { 353​ if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred) {
346 flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred; 354​ flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred;
347 } 355​ }
348 m_waylandOutput->addMode(mode.size, flags, mode.refreshRate); 356​ waylandOutput->addMode(mode.size, flags, mode.refreshRate);
349 } 357​ }
350 358​
351 m_waylandOutput->create(); 359​ waylandOutput->create();
360​ setWaylandOutput(waylandOutput.data());
352} 361​}
353 362​
354void DrmOutput::initOutputDevice(drmModeConnector *connector) 363​void DrmOutput::initOutputDevice(drmModeConnector *connector)
355{ 364​{
356 if (!m_waylandOutputDevice.isNull()) { 365​ auto waylandOutputDevice = getWaylandOutputDevice();
357 delete m_waylandOutputDevice.data(); 366​ if (!waylandOutputDevice.isNull()) {
358 m_waylandOutputDevice.clear(); 367​ delete waylandOutputDevice.data();
368​ waylandOutputDevice.clear();
359 } 369​ }
360 m_waylandOutputDevice = waylandServer()->display()->createOutputDevice(); 370​ waylandOutputDevice = waylandServer()->display()->createOutputDevice();
361 m_waylandOutputDevice->setUuid(m_uuid); 371​ waylandOutputDevice->setUuid(m_uuid);
362 372​
363 if (!m_edid.eisaId.isEmpty()) { 373​ if (!m_edid.eisaId.isEmpty()) {
364 m_waylandOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId)); 374​ waylandOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId));
365 } else { 375​ } else {
366 m_waylandOutputDevice->setManufacturer(i18n("unknown")); 376​ waylandOutputDevice->setManufacturer(i18n("unknown"));
367 } 377​ }
368 378​
369 QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown")); 379​ QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown"));
370 QString modelName; 380​ QString modelName;
371 381​
372 if (!m_edid.monitorName.isEmpty()) { 382​ if (!m_edid.monitorName.isEmpty()) {
373 QString model = QString::fromLatin1(m_edid.monitorName); 383​ QString model = QString::fromLatin1(m_edid.monitorName);
374 if (!m_edid.serialNumber.isEmpty()) { 384​ if (!m_edid.serialNumber.isEmpty()) {
375 model.append('/'); 385​ model.append('/');
376 model.append(QString::fromLatin1(m_edid.serialNumber)); 386​ model.append(QString::fromLatin1(m_edid.serialNumber));
377 } 387​ }
378 modelName = model; 388​ modelName = model;
379 } else if (!m_edid.serialNumber.isEmpty()) { 389​ } else if (!m_edid.serialNumber.isEmpty()) {
380 modelName = QString::fromLatin1(m_edid.serialNumber); 390​ modelName = QString::fromLatin1(m_edid.serialNumber);
381 } else { 391​ } else {
382 modelName = i18n("unknown"); 392​ modelName = i18n("unknown");
383 } 393​ }
384 394​
385 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);
386 396​
387 m_waylandOutputDevice->setPhysicalSize(m_physicalSize); 397​ waylandOutputDevice->setPhysicalSize(rawPhysicalSize());
388 398​
389 // read in mode information 399​ // read in mode information
390 for (int i = 0; i < connector->count_modes; ++i) { 400​ for (int i = 0; i < connector->count_modes; ++i) {
391 // 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
392 // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set 402​ // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set
393 auto *m = &connector->modes[i]; 403​ auto *m = &connector->modes[i];
394 KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags; 404​ KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags;
395 if (isCurrentMode(m)) { 405​ if (isCurrentMode(m)) {
396 deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current; 406​ deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
397 } 407​ }
398 if (m->type & DRM_MODE_TYPE_PREFERRED) { 408​ if (m->type & DRM_MODE_TYPE_PREFERRED) {
399 deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred; 409​ deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred;
400 } 410​ }
401 411​
402 const auto refreshRate = refreshRateForMode(m); 412​ const auto refreshRate = refreshRateForMode(m);
403 413​
404 KWayland::Server::OutputDeviceInterface::Mode mode; 414​ KWayland::Server::OutputDeviceInterface::Mode mode;
405 mode.id = i; 415​ mode.id = i;
406 mode.size = QSize(m->hdisplay, m->vdisplay); 416​ mode.size = QSize(m->hdisplay, m->vdisplay);
407 mode.flags = deviceflags; 417​ mode.flags = deviceflags;
408 mode.refreshRate = refreshRate; 418​ mode.refreshRate = refreshRate;
409 qCDebug(KWIN_DRM) << "Adding mode: " << i << mode.size; 419​ qCDebug(KWIN_DRM) << "Adding mode: " << i << mode.size;
410 m_waylandOutputDevice->addMode(mode); 420​ waylandOutputDevice->addMode(mode);
411 } 421​ }
412 m_waylandOutputDevice->create(); 422​ waylandOutputDevice->create();
423​ setWaylandOutputDevice(waylandOutputDevice.data());
413} 424​}
414 425​
415bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const 426​bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const
416{ 427​{
417 return mode->clock == m_mode.clock 428​ return mode->clock == m_mode.clock
418 && mode->hdisplay == m_mode.hdisplay 429​ && mode->hdisplay == m_mode.hdisplay
419 && mode->hsync_start == m_mode.hsync_start 430​ && mode->hsync_start == m_mode.hsync_start
420 && 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 {
699 m_dpmsMode = m_dpmsModePending; 710​ m_dpmsMode = m_dpmsModePending;
700 } 711​ }
701} 712​}
702 713​
703void DrmOutput::dpmsOnHandler() 714​void DrmOutput::dpmsOnHandler()
704{ 715​{
705 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.";
706 717​
707 if (m_waylandOutput) { 718​ auto waylandOutput = getWaylandOutput();
708 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending)); 719​ if (waylandOutput) {
720​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
709 } 721​ }
710 emit dpmsChanged(); 722​ emit dpmsChanged();
711 723​
712 m_backend->checkOutputsAreOn(); 724​ m_backend->checkOutputsAreOn();
713 if (!m_backend->atomicModeSetting()) { 725​ if (!m_backend->atomicModeSetting()) {
714 m_crtc->blank(); 726​ m_crtc->blank();
715 } 727​ }
716 if (Compositor *compositor = Compositor::self()) { 728​ if (Compositor *compositor = Compositor::self()) {
717 compositor->addRepaintFull(); 729​ compositor->addRepaintFull();
718 } 730​ }
719} 731​}
720 732​
721void DrmOutput::dpmsOffHandler() 733​void DrmOutput::dpmsOffHandler()
722{ 734​{
723 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.";
724 736​
725 if (m_waylandOutput) { 737​ auto waylandOutput = getWaylandOutput();
726 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending)); 738​ if (waylandOutput) {
739​ waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
727 } 740​ }
728 emit dpmsChanged(); 741​ emit dpmsChanged();
729 742​
730 m_backend->outputWentOff(); 743​ m_backend->outputWentOff();
731} 744​}
732 745​
733int DrmOutput::currentRefreshRate() const 746​int DrmOutput::currentRefreshRate() const
734{ 747​{
735 if (!m_waylandOutput) { 748​ auto waylandOutput = getWaylandOutput();
749​ if (!waylandOutput) {
736 return 60000; 750​ return 60000;
737 } 751​ }
738 return m_waylandOutput->refreshRate(); 752​ return waylandOutput->refreshRate();
739} 753​}
740 754​
741bool DrmOutput::commitChanges() 755​bool DrmOutput::commitChanges()
742{ 756​{
743 Q_ASSERT(!m_waylandOutputDevice.isNull()); 757​ auto waylandOutputDevice = getWaylandOutputDevice();
758​ Q_ASSERT(!waylandOutputDevice.isNull());
759​
760​ auto changeset = getChangeset();
744 761​
745 if (m_changeset.isNull()) { 762​ if (changeset.isNull()) {
746 qCDebug(KWIN_DRM) << "no changes"; 763​ qCDebug(KWIN_DRM) << "no changes";
747 // No changes to an output is an entirely valid thing 764​ // No changes to an output is an entirely valid thing
748 return true; 765​ return true;
749 } 766​ }
750 //enabledChanged is handled by drmbackend 767​ //enabledChanged is handled by drmbackend
751 if (m_changeset->modeChanged()) { 768​ if (changeset->modeChanged()) {
752 qCDebug(KWIN_DRM) << "Setting new mode:" << m_changeset->mode(); 769​ qCDebug(KWIN_DRM) << "Setting new mode:" << changeset->mode();
753 m_waylandOutputDevice->setCurrentMode(m_changeset->mode()); 770​ waylandOutputDevice->setCurrentMode(changeset->mode());
754 updateMode(m_changeset->mode()); 771​ updateMode(changeset->mode());
755 } 772​ }
756 if (m_changeset->transformChanged()) { 773​ if (changeset->transformChanged()) {
757 qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(m_changeset->transform()); 774​ qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(changeset->transform());
758 transform(m_changeset->transform()); 775​ transform(changeset->transform());
759 } 776​ }
760 if (m_changeset->positionChanged()) { 777​ if (changeset->positionChanged()) {
761 qCDebug(KWIN_DRM) << "Server setting position: " << m_changeset->position(); 778​ qCDebug(KWIN_DRM) << "Server setting position: " << changeset->position();
762 setGlobalPos(m_changeset->position()); 779​ setGlobalPos(changeset->position());
763 // may just work already! 780​ // may just work already!
764 } 781​ }
765 if (m_changeset->scaleChanged()) { 782​ if (changeset->scaleChanged()) {
766 qCDebug(KWIN_DRM) << "Setting scale:" << m_changeset->scale(); 783​ qCDebug(KWIN_DRM) << "Setting scale:" << changeset->scale();
767 setScale(m_changeset->scale()); 784​ setScale(changeset->scale());
768 } 785​ }
769 return true; 786​ return true;
770} 787​}
771 788​
772void DrmOutput::transform(KWayland::Server::OutputDeviceInterface::Transform transform) 789​void DrmOutput::transform(KWayland::Server::OutputDeviceInterface::Transform transform)
773{ 790​{
774 m_waylandOutputDevice->setTransform(transform); 791​ getWaylandOutputDevice()->setTransform(transform);
775 using KWayland::Server::OutputDeviceInterface; 792​ using KWayland::Server::OutputDeviceInterface;
776 using KWayland::Server::OutputInterface; 793​ using KWayland::Server::OutputInterface;
794​ auto waylandOutput = getWaylandOutput();
795​
777 switch (transform) { 796​ switch (transform) {
778 case OutputDeviceInterface::Transform::Normal: 797​ case OutputDeviceInterface::Transform::Normal:
779 if (m_primaryPlane) { 798​ if (m_primaryPlane) {
780 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0); 799​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0);
781 } 800​ }
782 if (m_waylandOutput) { 801​ if (waylandOutput) {
783 m_waylandOutput->setTransform(OutputInterface::Transform::Normal); 802​ waylandOutput->setTransform(OutputInterface::Transform::Normal);
784 } 803​ }
785 m_orientation = Qt::PrimaryOrientation; 804​ setOrientation(Qt::PrimaryOrientation);
786 break; 805​ break;
787 case OutputDeviceInterface::Transform::Rotated90: 806​ case OutputDeviceInterface::Transform::Rotated90:
788 if (m_primaryPlane) { 807​ if (m_primaryPlane) {
789 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate90); 808​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate90);
790 } 809​ }
791 if (m_waylandOutput) { 810​ if (waylandOutput) {
792 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated90); 811​ waylandOutput->setTransform(OutputInterface::Transform::Rotated90);
793 } 812​ }
794 m_orientation = Qt::PortraitOrientation; 813​ setOrientation(Qt::PortraitOrientation);
795 break; 814​ break;
796 case OutputDeviceInterface::Transform::Rotated180: 815​ case OutputDeviceInterface::Transform::Rotated180:
797 if (m_primaryPlane) { 816​ if (m_primaryPlane) {
798 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate180); 817​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate180);
799 } 818​ }
800 if (m_waylandOutput) { 819​ if (waylandOutput) {
801 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated180); 820​ waylandOutput->setTransform(OutputInterface::Transform::Rotated180);
802 } 821​ }
803 m_orientation = Qt::InvertedLandscapeOrientation; 822​ setOrientation(Qt::InvertedLandscapeOrientation);
804 break; 823​ break;
805 case OutputDeviceInterface::Transform::Rotated270: 824​ case OutputDeviceInterface::Transform::Rotated270:
806 if (m_primaryPlane) { 825​ if (m_primaryPlane) {
807 m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate270); 826​ m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate270);
808 } 827​ }
809 if (m_waylandOutput) { 828​ if (waylandOutput) {
810 m_waylandOutput->setTransform(OutputInterface::Transform::Rotated270); 829​ waylandOutput->setTransform(OutputInterface::Transform::Rotated270);
811 } 830​ }
812 m_orientation = Qt::InvertedPortraitOrientation; 831​ setOrientation(Qt::InvertedPortraitOrientation);
813 break; 832​ break;
814 case OutputDeviceInterface::Transform::Flipped: 833​ case OutputDeviceInterface::Transform::Flipped:
815 // TODO: what is this exactly? 834​ // TODO: what is this exactly?
816 if (m_waylandOutput) { 835​ if (waylandOutput) {
817 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped); 836​ waylandOutput->setTransform(OutputInterface::Transform::Flipped);
818 } 837​ }
819 break; 838​ break;
820 case OutputDeviceInterface::Transform::Flipped90: 839​ case OutputDeviceInterface::Transform::Flipped90:
821 // TODO: what is this exactly? 840​ // TODO: what is this exactly?
822 if (m_waylandOutput) { 841​ if (waylandOutput) {
823 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped90); 842​ waylandOutput->setTransform(OutputInterface::Transform::Flipped90);
824 } 843​ }
825 break; 844​ break;
826 case OutputDeviceInterface::Transform::Flipped180: 845​ case OutputDeviceInterface::Transform::Flipped180:
827 // TODO: what is this exactly? 846​ // TODO: what is this exactly?
828 if (m_waylandOutput) { 847​ if (waylandOutput) {
829 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped180); 848​ waylandOutput->setTransform(OutputInterface::Transform::Flipped180);
830 } 849​ }
831 break; 850​ break;
832 case OutputDeviceInterface::Transform::Flipped270: 851​ case OutputDeviceInterface::Transform::Flipped270:
833 // TODO: what is this exactly? 852​ // TODO: what is this exactly?
834 if (m_waylandOutput) { 853​ if (waylandOutput) {
835 m_waylandOutput->setTransform(OutputInterface::Transform::Flipped270); 854​ waylandOutput->setTransform(OutputInterface::Transform::Flipped270);
836 } 855​ }
837 break; 856​ break;
838 } 857​ }
839 m_modesetRequested = true; 858​ m_modesetRequested = true;
840 // the cursor might need to get rotated 859​ // the cursor might need to get rotated
841 updateCursor(); 860​ updateCursor();
842 showCursor(); 861​ showCursor();
843 emit modeChanged(); 862​ emit modeChanged();
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Line(s)963{
957 976​
958 if (!doAtomicCommit(AtomicCommitMode::Test)) { 977​ if (!doAtomicCommit(AtomicCommitMode::Test)) {
959 //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?
960 //TODO: Probably should undo setNext and reset the flip list 979​ //TODO: Probably should undo setNext and reset the flip list
961 qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present."; 980​ qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present.";
962 // go back to previous state 981​ // go back to previous state
963 if (m_lastWorkingState.valid) { 982​ if (m_lastWorkingState.valid) {
964 m_mode = m_lastWorkingState.mode; 983​ m_mode = m_lastWorkingState.mode;
965 m_orientation = m_lastWorkingState.orientation; 984​ setOrientation(m_lastWorkingState.orientation);
966 setGlobalPos(m_lastWorkingState.globalPos); 985​ setGlobalPos(m_lastWorkingState.globalPos);
967 if (m_primaryPlane) { 986​ if (m_primaryPlane) {
968 m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations); 987​ m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations);
969 } 988​ }
970 m_modesetRequested = true; 989​ m_modesetRequested = true;
971 // the cursor might need to get rotated 990​ // the cursor might need to get rotated
972 updateCursor(); 991​ updateCursor();
973 showCursor(); 992​ showCursor();
974 // TODO: forward to OutputInterface and OutputDeviceInterface 993​ // TODO: forward to OutputInterface and OutputDeviceInterface
975 emit modeChanged(); 994​ emit modeChanged();
976 emit screens()->changed(); 995​ emit screens()->changed();
977 } 996​ }
978 return false; 997​ return false;
979 } 998​ }
980 const bool wasModeset = m_modesetRequested; 999​ const bool wasModeset = m_modesetRequested;
981 if (!doAtomicCommit(AtomicCommitMode::Real)) { 1000​ if (!doAtomicCommit(AtomicCommitMode::Real)) {
982 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.";
983 //TODO: Probably should undo setNext and reset the flip list 1002​ //TODO: Probably should undo setNext and reset the flip list
984 return false; 1003​ return false;
985 } 1004​ }
986 if (wasModeset) { 1005​ if (wasModeset) {
987 // store current mode set as new good state 1006​ // store current mode set as new good state
988 m_lastWorkingState.mode = m_mode; 1007​ m_lastWorkingState.mode = m_mode;
989 m_lastWorkingState.orientation = m_orientation; 1008​ m_lastWorkingState.orientation = orientation();
990 m_lastWorkingState.globalPos = m_globalPos; 1009​ m_lastWorkingState.globalPos = globalPos();
991 if (m_primaryPlane) { 1010​ if (m_primaryPlane) {
992 m_lastWorkingState.planeTransformations = m_primaryPlane->transformation(); 1011​ m_lastWorkingState.planeTransformations = m_primaryPlane->transformation();
993 } 1012​ }
994 m_lastWorkingState.valid = true; 1013​ m_lastWorkingState.valid = true;
995 } 1014​ }
996 m_pageFlipPending = true; 1015​ m_pageFlipPending = true;
997 return true; 1016​ return true;
998} 1017​}
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines