KisCanvasSurfaceColorSpaceManager Class Reference

#include <KisCanvasSurfaceColorSpaceManager.h>

Inheritance diagram for KisCanvasSurfaceColorSpaceManager:

Signals
void	sigDisplayConfigChanged (const KisDisplayConfig &config)

Public Member Functions
QString	colorManagementReport () const
KisDisplayConfig	displayConfig () const
bool	isReady () const
	KisCanvasSurfaceColorSpaceManager (KisSurfaceColorManagerInterface *interface, const KisConfig::CanvasSurfaceMode surfaceMode, const KisDisplayConfig::Options &options, QObject *parent=nullptr)
QString	osPreferredColorSpaceReport () const
	Private (KisSurfaceColorManagerInterface *interface)
void	setDisplayConfigOptions (const KisConfig::CanvasSurfaceMode surfaceMode, const KisDisplayConfig::Options &options)
void	setDisplayConfigOptions (const KisDisplayConfig::Options &options)
	~KisCanvasSurfaceColorSpaceManager ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static KisSurfaceColorimetry::RenderIntent	calculateConfigIntent (const KisDisplayConfig::Options &options)

Public Attributes
KisDisplayConfig	currentConfig
QScopedPointer< KisSurfaceColorManagerInterface >	interface
std::optional< KisSurfaceColorimetry::RenderIntent >	proofingIntentOverride
KisConfig::CanvasSurfaceMode	surfaceMode = KisConfig::CanvasSurfaceMode::Preferred
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Slots
void	slotInterfacePreferredDescriptionChanged ()
void	slotInterfaceReadyChanged (bool isReady)

Private Member Functions
void	reinitializeSurfaceDescription (const KisDisplayConfig::Options &newOptions)

Private Attributes
QScopedPointer< Private >	m_d

Detailed Description

Definition at line 20 of file KisCanvasSurfaceColorSpaceManager.cpp.

Constructor & Destructor Documentation

KisCanvasSurfaceColorSpaceManager()

KisCanvasSurfaceColorSpaceManager::KisCanvasSurfaceColorSpaceManager	(	KisSurfaceColorManagerInterface *	interface,
		const KisConfig::CanvasSurfaceMode	surfaceMode,
		const KisDisplayConfig::Options &	options,
		QObject *	parent = nullptr )

Definition at line 32 of file KisCanvasSurfaceColorSpaceManager.cpp.

    : QObject(parent)
    , m_d(new Private(interface))
{
    m_d->currentConfig.profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
    m_d->currentConfig.setOptions(options);
    m_d->currentConfig.isHDR = false;
    m_d->surfaceMode = surfaceMode;
 
    connect(m_d->interface.data(), &KisSurfaceColorManagerInterface::sigReadyChanged, this, &KisCanvasSurfaceColorSpaceManager::slotInterfaceReadyChanged);
    connect(m_d->interface.data(), &KisSurfaceColorManagerInterface::sigPreferredSurfaceDescriptionChanged, this, &KisCanvasSurfaceColorSpaceManager::slotInterfacePreferredDescriptionChanged);
 
    if (m_d->interface->isReady()) {
        slotInterfaceReadyChanged(true);
    }
}

References KoColorSpaceRegistry::instance(), m_d, KoColorSpaceRegistry::p709SRGBProfile(), KisSurfaceColorManagerInterface::sigPreferredSurfaceDescriptionChanged(), KisSurfaceColorManagerInterface::sigReadyChanged(), slotInterfacePreferredDescriptionChanged(), slotInterfaceReadyChanged(), and surfaceMode.

~KisCanvasSurfaceColorSpaceManager()

KisCanvasSurfaceColorSpaceManager::~KisCanvasSurfaceColorSpaceManager

(

)

Definition at line 52 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
}

Member Function Documentation

calculateConfigIntent()

static KisSurfaceColorimetry::RenderIntent KisCanvasSurfaceColorSpaceManager::calculateConfigIntent ( const KisDisplayConfig::Options & options )

static

colorManagementReport()

QString KisCanvasSurfaceColorSpaceManager::colorManagementReport

(

)

const

Definition at line 56 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    QString report;
    QDebug str(&report);
 
    if (!m_d->interface->isReady()) {
        str << "WARNING: surface color management interface is not ready!" << Qt::endl;
        str << Qt::endl;
    }
 
    using KisSurfaceColorimetry::RenderIntent;
    using KisSurfaceColorimetry::SurfaceDescription;
    using KisSurfaceColorimetry::NamedPrimaries;
    using KisSurfaceColorimetry::NamedTransferFunction;
 
    str << "Configured mode:" << m_d->surfaceMode << Qt::endl;
 
    RenderIntent preferredIntent = Private::calculateConfigIntent(m_d->currentConfig.options());
    str << "Configured intent:" << preferredIntent << "supported:" << m_d->interface->supportsRenderIntent(preferredIntent) << Qt::endl;
 
    str << "Actual intent:";
    if (m_d->interface->renderingIntent()) {
        str << *m_d->interface->renderingIntent() << Qt::endl;
    } else {
        str << "<none>" << Qt::endl;
    }
    str << Qt::endl;
 
    str << "Active surface description:";
    if (m_d->interface->surfaceDescription()) {
        str << Qt::endl;
        str.noquote() << m_d->interface->surfaceDescription()->makeTextReport() << Qt::endl;
    } else {
        str << "<none>" << Qt::endl;
    }
    str << Qt::endl;
 
    str << "Selected Profile:";
    if (m_d->currentConfig.profile) {
        auto profile = m_d->currentConfig.profile;
 
        str << profile->name() << Qt::endl;
        str << "    primaries:" << KoColorProfile::getColorPrimariesName(profile->getColorPrimaries()) << Qt::endl;
        str << "    transfer: " << KoColorProfile::getTransferCharacteristicName(profile->getTransferCharacteristics()) << Qt::endl;
        str << Qt::endl;
 
        {
            auto colVec = profile->getColorantsxyY();
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(colVec.size() == 9, report);
            KisColorimetryUtils::xyY colR{colVec[0], colVec[1], colVec[2]};
            KisColorimetryUtils::xyY colG{colVec[3], colVec[4], colVec[5]};
            KisColorimetryUtils::xyY colB{colVec[6], colVec[7], colVec[8]};
 
            str << "    red:  " << colR << Qt::endl;
            str << "    green:" << colG << Qt::endl;
            str << "    blue: " << colB << Qt::endl;
        }
 
        {
            auto whiteVec = profile->getWhitePointxyY();
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(whiteVec.size() == 3, report);
            KisColorimetryUtils::xyY white{whiteVec[0], whiteVec[1], whiteVec[2]};
 
            str << "    white: " << white << Qt::endl;
            str << Qt::endl;
        }
 
    } else {
        str << "<none>" << Qt::endl;
    }
 
    str << "Compositor preferred surface description:";
    if (m_d->interface->preferredSurfaceDescription()) {
        str << Qt::endl;
        str.noquote() << m_d->interface->preferredSurfaceDescription()->makeTextReport() << Qt::endl;
    } else {
        str << "<none>" << Qt::endl;
    }
    str << Qt::endl;
 
    return report;
}

References KoColorProfile::getColorPrimariesName(), KoColorProfile::getTransferCharacteristicName(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

displayConfig()

KisDisplayConfig KisCanvasSurfaceColorSpaceManager::displayConfig

(

)

const

Definition at line 423 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    return m_d->currentConfig;
}

References m_d.

isReady()

bool KisCanvasSurfaceColorSpaceManager::isReady

(

)

const

Definition at line 418 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    return m_d->interface->isReady();
}

References m_d.

osPreferredColorSpaceReport()

QString KisCanvasSurfaceColorSpaceManager::osPreferredColorSpaceReport

(

)

const

Definition at line 139 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    QString report;
    QDebug str(&report);
 
    if (!m_d->interface->isReady()) {
        str << "WARNING: surface color management interface is not ready!" << Qt::endl;
        str << Qt::endl;
    }
 
    if (m_d->interface->preferredSurfaceDescription()) {
        str << Qt::endl;
        str.noquote() << m_d->interface->preferredSurfaceDescription()->makeTextReport() << Qt::endl;
    } else {
        str << "<none>" << Qt::endl;
    }
 
    return report;
}

References m_d.

Private()

KisCanvasSurfaceColorSpaceManager::Private ( KisSurfaceColorManagerInterface * interface )

inline

Definition at line 22 of file KisCanvasSurfaceColorSpaceManager.cpp.

: interface(interface) {}

reinitializeSurfaceDescription()

void KisCanvasSurfaceColorSpaceManager::reinitializeSurfaceDescription ( const KisDisplayConfig::Options & newOptions )

private

Our definition of rec709-g10 is different from the one used in Wayland. Krita defines it as "value 1.0 is reference white" and everything above is HDR values. But Wayland declares it as "0.0...1.0 is the full HDR range" and reference white value being put somewhere inbetween. It technically allows Wayland to use 10-bit integer surfaces for rec709-g10 space, which is a bad idea in general (due to potential resolution limit). But given that Wayland/Mesa doesn't seem to support 16-bit float surfaces, that is the only option they have.

Anyway, due to limitations of 10-bit integer surfaces in rec709-g10 mode, we just refuse to support that.

Definition at line 216 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    using KisSurfaceColorimetry::NamedPrimaries;
    using KisSurfaceColorimetry::NamedTransferFunction;
    using KisSurfaceColorimetry::RenderIntent;
    using KisSurfaceColorimetry::SurfaceDescription;
 
    RenderIntent preferredIntent =
        Private::calculateConfigIntent(newOptions);
 
    if (!m_d->interface->supportsRenderIntent(preferredIntent)) {
        qWarning() << "WARNING: failed to set user preferred rendering"
                   << "intent for the surface, intent \""
                   << preferredIntent << "\" is unsupported, falling back to \"perceptual\"";
 
        preferredIntent = RenderIntent::render_intent_perceptual;
 
        // perceptual intent is guaranteed to be supported by the compositor
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->interface->supportsRenderIntent(preferredIntent));
    }
 
    std::optional<SurfaceDescription> requestedDescription;
    const KoColorProfile *profile = nullptr;
 
    if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Unmanaged) {
        profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
    } else {
        requestedDescription = SurfaceDescription();
 
        using namespace KisSurfaceColorimetry;
 
        const auto compositorPreferred = m_d->interface->preferredSurfaceDescription();
        KIS_SAFE_ASSERT_RECOVER_RETURN(compositorPreferred);
 
        // we have our own definition of the Rec2020PQ space with
        // the reference point fixed to 80 cd/m2
        auto makeKritaRec2020PQLuminance = [] () {
            Luminance luminance;
            luminance.minLuminance = 0;
            luminance.referenceLuminance = 80;
            luminance.maxLuminance = 10000;
            return luminance;
        };
 
        if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Preferred) {
 
            if (compositorPreferred->colorSpace.isHDR()) {
                // we support HDR only via Rec2020PQ, so reset the color space to that
                // (KWin 6.5+ reports gamma-2.2 as preferred color space for whatever
                //  reason)
                requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_bt2020;
                requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_st2084_pq;
            } else {
                // we don't copy mastering properties, since they mean a different thing
                // for the preferred space and outputs
                requestedDescription->colorSpace = compositorPreferred->colorSpace;
            }
 
            if (std::holds_alternative<NamedTransferFunction>(requestedDescription->colorSpace.transferFunction) &&
                std::get<NamedTransferFunction>(requestedDescription->colorSpace.transferFunction) == NamedTransferFunction::transfer_function_st2084_pq) {
 
                requestedDescription->colorSpace.luminance = makeKritaRec2020PQLuminance();
            }
        } else if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Rec2020pq) {
            requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_bt2020;
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_st2084_pq;
            requestedDescription->colorSpace.luminance = makeKritaRec2020PQLuminance();
        } else if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Rec709g22) {
            requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_srgb;
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_gamma22;
            if (compositorPreferred->colorSpace.luminance) {
                // rec709-g22 is considered as SDR in lcms, so we should our space to SDR range
                requestedDescription->colorSpace.luminance = 
                    compositorPreferred->colorSpace.luminance->clipToSdr();
            }
        } else if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Rec709g10) {
            requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_srgb;
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_ext_linear;
            if (compositorPreferred->colorSpace.luminance) {
                requestedDescription->colorSpace.luminance = 
                    compositorPreferred->colorSpace.luminance->clipToSdr();
            }
        }
 
        if (std::holds_alternative<NamedPrimaries>(requestedDescription->colorSpace.primaries) &&
            std::get<NamedPrimaries>(requestedDescription->colorSpace.primaries) == NamedPrimaries::primaries_unknown) {
 
            requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_srgb;
        }
 
        if (std::holds_alternative<NamedTransferFunction>(requestedDescription->colorSpace.transferFunction) &&
            std::get<NamedTransferFunction>(requestedDescription->colorSpace.transferFunction) == NamedTransferFunction::transfer_function_unknown) {
 
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_gamma22;
        }
 
        if (!m_d->interface->supportsSurfaceDescription(*requestedDescription)) {
 
            // try pure sRGB
            requestedDescription->colorSpace.primaries = NamedPrimaries::primaries_srgb;
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_srgb;
 
            if (!m_d->interface->supportsSurfaceDescription(*requestedDescription)) {
                requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_gamma22;
 
                if (!m_d->interface->supportsSurfaceDescription(*requestedDescription)) {
                    qWarning() << "WARNING: failed to find a suitable surface format for the compositor";
                    return; // TODO: extra signals?
                }
            }
        }
 
        {
            auto request = colorSpaceToRequest(requestedDescription->colorSpace);
            if (request.isValid()) {
                profile = KoColorSpaceRegistry::instance()->profileFor(request.colorants,
                                                                       request.colorPrimariesType,
                                                                       request.transferFunction);
            }
        }
 
        if (!profile) {
            // keep primaries, but change the transfer function to gamma22
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_gamma22;
            if (m_d->interface->supportsSurfaceDescription(*requestedDescription)) {
                auto request = colorSpaceToRequest(requestedDescription->colorSpace);
                if (request.isValid()) {
                    profile = KoColorSpaceRegistry::instance()->profileFor(request.colorants,
                                                                           request.colorPrimariesType,
                                                                           request.transferFunction);
                }
            }
        }
 
        if (!profile) {
            // keep primaries, but change the transfer function to srgb
            requestedDescription->colorSpace.transferFunction = NamedTransferFunction::transfer_function_srgb;
            if (m_d->interface->supportsSurfaceDescription(*requestedDescription)) {
                auto request = colorSpaceToRequest(requestedDescription->colorSpace);
                if (request.isValid()) {
                    profile = KoColorSpaceRegistry::instance()->profileFor(request.colorants,
                                                                           request.colorPrimariesType,
                                                                           request.transferFunction);
                }
            }
        }
 
        if (!profile) {
            qWarning() << "WARNING: failed to to create a profile for the compositor's preferred color space";
            qWarning() << "    " << ppVar(compositorPreferred);
            qWarning() << "    " << ppVar(*requestedDescription);
            // TODO: debug all supported values for the compositor
            return; // TODO: extra signals?
        }
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(profile);
    KIS_SAFE_ASSERT_RECOVER_RETURN(!requestedDescription || m_d->interface->supportsSurfaceDescription(*requestedDescription));
 
    if (m_d->interface->surfaceDescription() != requestedDescription ||
        m_d->interface->renderingIntent() != preferredIntent) {
 
        if (requestedDescription) {
            auto future = m_d->interface->setSurfaceDescription(*requestedDescription, preferredIntent);
            future.then([](QFuture<bool> result) {
                if (!result.isValid() || !result.result()) {
                    qWarning()
                        << "WARNING: failed to set color space for the surface, setSurfaceDescription() returned false";
                }
            });
        } else {
            m_d->interface->unsetSurfaceDescription();
        }
    }
 
    const bool requestedDescriptionIsHDR = requestedDescription && requestedDescription->colorSpace.isHDR();
 
    KisDisplayConfig newDisplayConfig;
    newDisplayConfig.profile = profile;
    newDisplayConfig.setOptions(newOptions); // TODO: think about failure to set the intent and infinite update loop
    newDisplayConfig.isHDR = requestedDescriptionIsHDR;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->currentConfig.profile);
 
    if (m_d->currentConfig != newDisplayConfig) {
        m_d->currentConfig = newDisplayConfig;
        Q_EMIT sigDisplayConfigChanged(m_d->currentConfig);
    }
}

References KoColorSpaceRegistry::instance(), KisDisplayConfig::isHDR, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisSurfaceColorimetry::Luminance::maxLuminance, KisSurfaceColorimetry::Luminance::minLuminance, KoColorSpaceRegistry::p709SRGBProfile(), ppVar, KisConfig::Preferred, KisDisplayConfig::profile, KoColorSpaceRegistry::profileFor(), KisConfig::Rec2020pq, KisConfig::Rec709g10, KisConfig::Rec709g22, KisSurfaceColorimetry::Luminance::referenceLuminance, KisDisplayConfig::setOptions(), sigDisplayConfigChanged(), and KisConfig::Unmanaged.

setDisplayConfigOptions() [1/2]

void KisCanvasSurfaceColorSpaceManager::setDisplayConfigOptions	(	const KisConfig::CanvasSurfaceMode	surfaceMode,
		const KisDisplayConfig::Options &	options )

Definition at line 187 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    if (!m_d->interface->isReady()) return;
    if (surfaceMode == m_d->surfaceMode && options == m_d->currentConfig.options()) return;
 
    m_d->surfaceMode = surfaceMode;
    reinitializeSurfaceDescription(options);
}

References m_d, reinitializeSurfaceDescription(), and surfaceMode.

setDisplayConfigOptions() [2/2]

void KisCanvasSurfaceColorSpaceManager::setDisplayConfigOptions

(

const KisDisplayConfig::Options &

options

)

Definition at line 196 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    setDisplayConfigOptions(m_d->surfaceMode, options);
}

References m_d, and setDisplayConfigOptions().

sigDisplayConfigChanged

void KisCanvasSurfaceColorSpaceManager::sigDisplayConfigChanged ( const KisDisplayConfig & config )

signal

slotInterfacePreferredDescriptionChanged

void KisCanvasSurfaceColorSpaceManager::slotInterfacePreferredDescriptionChanged ( )

privateslot

Definition at line 208 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    reinitializeSurfaceDescription(m_d->currentConfig.options());
}

References m_d, and reinitializeSurfaceDescription().

slotInterfaceReadyChanged

void KisCanvasSurfaceColorSpaceManager::slotInterfaceReadyChanged ( bool isReady )

privateslot

Definition at line 201 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    if (isReady) {
        reinitializeSurfaceDescription(m_d->currentConfig.options());
    }
}

References isReady(), m_d, and reinitializeSurfaceDescription().

Member Data Documentation

currentConfig

KisDisplayConfig KisCanvasSurfaceColorSpaceManager::currentConfig

Definition at line 25 of file KisCanvasSurfaceColorSpaceManager.cpp.

interface

QScopedPointer<KisSurfaceColorManagerInterface> KisCanvasSurfaceColorSpaceManager::interface

Definition at line 24 of file KisCanvasSurfaceColorSpaceManager.cpp.

m_d

QScopedPointer<Private> KisCanvasSurfaceColorSpaceManager::m_d

private

Definition at line 49 of file KisCanvasSurfaceColorSpaceManager.h.

proofingIntentOverride

std::optional<KisSurfaceColorimetry::RenderIntent> KisCanvasSurfaceColorSpaceManager::proofingIntentOverride

Definition at line 26 of file KisCanvasSurfaceColorSpaceManager.cpp.

surfaceMode

KisConfig::CanvasSurfaceMode KisCanvasSurfaceColorSpaceManager::surfaceMode = KisConfig::CanvasSurfaceMode::Preferred

Definition at line 27 of file KisCanvasSurfaceColorSpaceManager.cpp.

---

The documentation for this class was generated from the following files:

• libs/ui/KisCanvasSurfaceColorSpaceManager.cpp
• libs/ui/KisCanvasSurfaceColorSpaceManager.h