ScreenId.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
// Compositor-portable EDID parsing + screen-ID format helpers.
//
// Header-only inline so PhosphorIdentity stays INTERFACE — the cross-
// process consumers (KWin effect, Wayfire plugin, daemon) all share one
// definition without anyone shipping an extra .so. The function-local
// static caches are guaranteed unique across translation units by the
// C++17 inline-function-static rule.
 
#include <QByteArray>
#include <QDir>
#include <QFile>
#include <QHash>
#include <QIODevice>
#include <QLatin1Char>
#include <QLatin1String>
#include <QString>
#include <QStringList>
 
#include <cstdint>
 
namespace PhosphorIdentity {
 
namespace ScreenId {
 
namespace detail {
 
inline QHash<QString, QString>& edidSerialCache()
{
    static QHash<QString, QString> s_cache;
    return s_cache;
}
 
inline QHash<QString, int>& edidMissCounter()
{
    static QHash<QString, int> s_counter;
    return s_counter;
}
 
} // namespace detail
 
inline QString readEdidHeaderSerial(const QString& connectorName)
{
    auto& cache = detail::edidSerialCache();
    auto cacheIt = cache.constFind(connectorName);
    if (cacheIt != cache.constEnd()) {
        return *cacheIt;
    }
 
    QString result;
 
    QDir drmDir(QStringLiteral("/sys/class/drm"));
    if (drmDir.exists()) {
        const QStringList entries = drmDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
        for (const QString& entry : entries) {
            int dashPos = entry.indexOf(QLatin1Char('-'));
            if (dashPos < 0) {
                continue;
            }
            if (entry.mid(dashPos + 1) != connectorName) {
                continue;
            }
            QFile edidFile(drmDir.filePath(entry) + QStringLiteral("/edid"));
            if (!edidFile.open(QIODevice::ReadOnly)) {
                continue;
            }
            QByteArray header = edidFile.read(16);
            if (header.size() < 16) {
                continue;
            }
            const auto* data = reinterpret_cast<const uint8_t*>(header.constData());
            if (data[0] != 0x00 || data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF || data[4] != 0xFF
                || data[5] != 0xFF || data[6] != 0xFF || data[7] != 0x00) {
                continue;
            }
            uint32_t serial = data[12] | (static_cast<uint32_t>(data[13]) << 8)
                | (static_cast<uint32_t>(data[14]) << 16) | (static_cast<uint32_t>(data[15]) << 24);
            if (serial != 0) {
                result = QString::number(serial);
                break;
            }
        }
    }
 
    if (!result.isEmpty()) {
        cache.insert(connectorName, result);
        detail::edidMissCounter().remove(connectorName);
    } else {
        constexpr int maxRetries = 3;
        int& misses = detail::edidMissCounter()[connectorName];
        ++misses;
        if (misses >= maxRetries) {
            cache.insert(connectorName, result);
        }
    }
    return result;
}
 
inline void invalidateEdidCache(const QString& connectorName = QString())
{
    if (connectorName.isEmpty()) {
        detail::edidSerialCache().clear();
        detail::edidMissCounter().clear();
    } else {
        detail::edidSerialCache().remove(connectorName);
        detail::edidMissCounter().remove(connectorName);
    }
}
 
inline QString normalizeHexSerial(const QString& serial)
{
    if (!serial.isEmpty() && serial.startsWith(QLatin1String("0x"), Qt::CaseInsensitive)) {
        bool ok = false;
        uint32_t numericSerial = serial.toUInt(&ok, 16);
        if (ok && numericSerial != 0) {
            return QString::number(numericSerial);
        }
    }
    return serial;
}
 
inline QString buildBaseId(const QString& manufacturer, const QString& model, const QString& serial)
{
    if (!serial.isEmpty()) {
        return manufacturer + QLatin1Char(':') + model + QLatin1Char(':') + serial;
    }
    if (!manufacturer.isEmpty() || !model.isEmpty()) {
        return manufacturer + QLatin1Char(':') + model;
    }
    return QString();
}
 
inline QString buildScreenBaseId(const QString& manufacturer, const QString& model, const QString& serialNumber,
                                 const QString& connectorName)
{
    QString serial = normalizeHexSerial(serialNumber);
    if (serial.isEmpty()) {
        serial = readEdidHeaderSerial(connectorName);
    }
    QString baseId = buildBaseId(manufacturer, model, serial);
    return baseId.isEmpty() ? connectorName : baseId;
}
 
} // namespace ScreenId
 
} // namespace PhosphorIdentity