output.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2019 Roman Gilg <subdiff@gmail.com>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
 
#include <kwin_export.h>
 
#include "renderloop.h"
#include "utils/edid.h"
 
#include <QDebug>
#include <QList>
#include <QMatrix4x4>
#include <QObject>
#include <QRect>
#include <QSize>
#include <QUuid>
 
namespace KWin
{
 
class RenderLoop;
class OutputConfiguration;
class ColorTransformation;
class IccProfile;
class OutputChangeSet;
 
class KWIN_EXPORT OutputTransform
{
public:
    enum Kind {
        Normal = 0, // no rotation
        Rotate90 = 1, // rotate 90 degrees counterclockwise
        Rotate180 = 2, // rotate 180 degrees counterclockwise
        Rotate270 = 3, // rotate 270 degrees counterclockwise
        FlipX = 4, // mirror horizontally
        FlipX90 = 5, // mirror horizontally, then rotate 90 degrees counterclockwise
        FlipX180 = 6, // mirror horizontally, then rotate 180 degrees counterclockwise
        FlipX270 = 7, // mirror horizontally, then rotate 270 degrees counterclockwise
        FlipY = FlipX180, // mirror vertically
        FlipY90 = FlipX270, // mirror vertically, then rotate 90 degrees counterclockwise
        FlipY180 = FlipX, // mirror vertically, then rotate 180 degrees counterclockwise
        FlipY270 = FlipX90, // mirror vertically, then rotate 270 degrees counterclockwise
    };
 
    OutputTransform() = default;
    OutputTransform(Kind kind)
        : m_kind(kind)
    {
    }
 
    bool operator<=>(const OutputTransform &other) const = default;
 
    Kind kind() const;
 
    OutputTransform inverted() const;
 
    QSizeF map(const QSizeF &size) const;
    QSize map(const QSize &size) const;
 
    QRectF map(const QRectF &rect, const QSizeF &bounds) const;
    QRect map(const QRect &rect, const QSize &bounds) const;
 
    QPointF map(const QPointF &point, const QSizeF &bounds) const;
    QPoint map(const QPoint &point, const QSize &bounds) const;
 
    OutputTransform combine(OutputTransform other) const;
 
    QMatrix4x4 toMatrix() const;
 
private:
    Kind m_kind = Kind::Normal;
};
 
class KWIN_EXPORT OutputMode
{
public:
    enum class Flag : uint {
        Preferred = 0x1,
        Generated = 0x2,
    };
    Q_DECLARE_FLAGS(Flags, Flag)
 
    OutputMode(const QSize &size, uint32_t refreshRate, Flags flags = {});
    virtual ~OutputMode() = default;
 
    QSize size() const;
    uint32_t refreshRate() const;
    Flags flags() const;
 
private:
    const QSize m_size;
    const uint32_t m_refreshRate;
    const Flags m_flags;
};
 
class KWIN_EXPORT Output : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QRect geometry READ geometry NOTIFY geometryChanged)
    Q_PROPERTY(qreal devicePixelRatio READ scale NOTIFY scaleChanged)
    Q_PROPERTY(QString name READ name CONSTANT)
    Q_PROPERTY(QString manufacturer READ manufacturer CONSTANT)
    Q_PROPERTY(QString model READ model CONSTANT)
    Q_PROPERTY(QString serialNumber READ serialNumber CONSTANT)
 
public:
    enum class DpmsMode {
        On,
        Standby,
        Suspend,
        Off,
    };
    Q_ENUM(DpmsMode)
 
    enum class Capability : uint {
        Dpms = 1,
        Overscan = 1 << 1,
        Vrr = 1 << 2,
        RgbRange = 1 << 3,
        HighDynamicRange = 1 << 4,
        WideColorGamut = 1 << 5,
        AutoRotation = 1 << 6,
        IccProfile = 1 << 7,
        Tearing = 1 << 8,
    };
    Q_DECLARE_FLAGS(Capabilities, Capability)
 
    enum class SubPixel {
        Unknown,
        None,
        Horizontal_RGB,
        Horizontal_BGR,
        Vertical_RGB,
        Vertical_BGR,
    };
    Q_ENUM(SubPixel)
 
    enum class RgbRange {
        Automatic = 0,
        Full = 1,
        Limited = 2,
    };
    Q_ENUM(RgbRange)
 
    enum class AutoRotationPolicy {
        Never = 0,
        InTabletMode,
        Always
    };
    Q_ENUM(AutoRotationPolicy);
 
    explicit Output(QObject *parent = nullptr);
    ~Output() override;
 
    void ref();
    void unref();
 
    QRect mapFromGlobal(const QRect &rect) const;
 
    QRectF mapFromGlobal(const QRectF &rect) const;
 
    QRectF mapToGlobal(const QRectF &rect) const;
 
    Q_INVOKABLE QPointF mapToGlobal(const QPointF &pos) const;
    Q_INVOKABLE QPointF mapFromGlobal(const QPointF &pos) const;
 
    QString name() const;
 
    QUuid uuid() const;
 
    bool isEnabled() const;
 
    QRect geometry() const;
 
    QRectF geometryF() const;
 
    QRect rect() const;
 
    QRectF rectF() const;
 
    uint32_t refreshRate() const;
 
    bool isInternal() const;
 
    qreal scale() const;
 
    QSize physicalSize() const;
 
    QSize pixelSize() const;
    QSize modeSize() const;
 
    QString eisaId() const;
 
    QString manufacturer() const;
    QString model() const;
    QString serialNumber() const;
 
    virtual RenderLoop *renderLoop() const = 0;
 
    void inhibitDirectScanout();
    void uninhibitDirectScanout();
 
    bool directScanoutInhibited() const;
 
    static std::chrono::milliseconds dimAnimationTime();
 
    OutputTransform transform() const;
    OutputTransform manualTransform() const;
    QSize orientateSize(const QSize &size) const;
 
    void applyChanges(const OutputConfiguration &config);
 
    SubPixel subPixel() const;
    QString description() const;
    Capabilities capabilities() const;
    const Edid &edid() const;
    QList<std::shared_ptr<OutputMode>> modes() const;
    std::shared_ptr<OutputMode> currentMode() const;
    DpmsMode dpmsMode() const;
    virtual void setDpmsMode(DpmsMode mode);
 
    uint32_t overscan() const;
 
    VrrPolicy vrrPolicy() const;
    RgbRange rgbRange() const;
 
    bool isPlaceholder() const;
    bool isNonDesktop() const;
    OutputTransform panelOrientation() const;
    bool wideColorGamut() const;
    bool highDynamicRange() const;
    uint32_t sdrBrightness() const;
    AutoRotationPolicy autoRotationPolicy() const;
    std::shared_ptr<IccProfile> iccProfile() const;
    QString iccProfilePath() const;
    QByteArray mstPath() const;
 
    virtual bool setGammaRamp(const std::shared_ptr<ColorTransformation> &transformation);
    virtual bool setChannelFactors(const QVector3D &rgb);
 
    virtual bool updateCursorLayer();
 
    std::optional<double> maxPeakBrightness() const;
    std::optional<double> maxAverageBrightness() const;
    double minBrightness() const;
    std::optional<double> maxPeakBrightnessOverride() const;
    std::optional<double> maxAverageBrightnessOverride() const;
    std::optional<double> minBrightnessOverride() const;
 
    double sdrGamutWideness() const;
 
    const ColorDescription &colorDescription() const;
 
Q_SIGNALS:
    void geometryChanged();
    void enabledChanged();
    void scaleChanged();
 
    void aboutToTurnOff(std::chrono::milliseconds time);
 
    void wakeUp();
 
    void aboutToChange(OutputChangeSet *changeSet);
 
    void changed();
 
    void currentModeChanged();
    void modesChanged();
    void outputChange(const QRegion &damagedRegion);
    void transformChanged();
    void dpmsModeChanged();
    void capabilitiesChanged();
    void overscanChanged();
    void vrrPolicyChanged();
    void rgbRangeChanged();
    void wideColorGamutChanged();
    void sdrBrightnessChanged();
    void highDynamicRangeChanged();
    void autoRotationPolicyChanged();
    void iccProfileChanged();
    void iccProfilePathChanged();
    void brightnessMetadataChanged();
    void sdrGamutWidenessChanged();
    void colorDescriptionChanged();
 
protected:
    struct Information
    {
        QString name;
        QString manufacturer;
        QString model;
        QString serialNumber;
        QString eisaId;
        QSize physicalSize;
        Edid edid;
        SubPixel subPixel = SubPixel::Unknown;
        Capabilities capabilities;
        OutputTransform panelOrientation = OutputTransform::Normal;
        bool internal = false;
        bool placeholder = false;
        bool nonDesktop = false;
        QByteArray mstPath;
        std::optional<double> maxPeakBrightness;
        std::optional<double> maxAverageBrightness;
        double minBrightness = 0;
    };
 
    struct State
    {
        QPoint position;
        qreal scale = 1;
        OutputTransform transform = OutputTransform::Normal;
        OutputTransform manualTransform = OutputTransform::Normal;
        QList<std::shared_ptr<OutputMode>> modes;
        std::shared_ptr<OutputMode> currentMode;
        DpmsMode dpmsMode = DpmsMode::On;
        SubPixel subPixel = SubPixel::Unknown;
        bool enabled = false;
        uint32_t overscan = 0;
        RgbRange rgbRange = RgbRange::Automatic;
        bool wideColorGamut = false;
        bool highDynamicRange = false;
        uint32_t sdrBrightness = 200;
        AutoRotationPolicy autoRotatePolicy = AutoRotationPolicy::InTabletMode;
        QString iccProfilePath;
        std::shared_ptr<IccProfile> iccProfile;
        ColorDescription colorDescription = ColorDescription::sRGB;
        std::optional<double> maxPeakBrightnessOverride;
        std::optional<double> maxAverageBrightnessOverride;
        std::optional<double> minBrightnessOverride;
        double sdrGamutWideness = 0;
        VrrPolicy vrrPolicy = VrrPolicy::Automatic;
    };
 
    void setInformation(const Information &information);
    void setState(const State &state);
 
    State m_state;
    Information m_information;
    QUuid m_uuid;
    int m_directScanoutCount = 0;
    int m_refCount = 1;
};
 
inline QRect Output::rect() const
{
    return QRect(QPoint(0, 0), geometry().size());
}
 
inline QRectF Output::rectF() const
{
    return QRectF(QPointF(0, 0), geometryF().size());
}
 
KWIN_EXPORT QDebug operator<<(QDebug debug, const Output *output);
 
} // namespace KWin
 
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Output::Capabilities)