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 connect(), 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 395 of file KisCanvasSurfaceColorSpaceManager.cpp.

{
    return m_d->currentConfig;
}

References m_d.

isReady()

bool KisCanvasSurfaceColorSpaceManager::isReady

(

)

const

Definition at line 390 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

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);
 
        if (m_d->surfaceMode == KisConfig::CanvasSurfaceMode::Preferred) {
            // 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) {
 
                // we have our own definition of the Rec2020PQ space with
                // the reference point fixed to 80 cd/m2
                requestedDescription->colorSpace.luminance = Luminance();
                requestedDescription->colorSpace.luminance->minLuminance = 0;
                requestedDescription->colorSpace.luminance->referenceLuminance = 80;
                requestedDescription->colorSpace.luminance->maxLuminance = 10000;
            }
 
        } 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) {
                // rec709-g22 is considered as SDR in lcms, so we should our space to SDR range
                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, KoColorSpaceRegistry::p709SRGBProfile(), ppVar, KisConfig::Preferred, KisDisplayConfig::profile, KoColorSpaceRegistry::profileFor(), KisConfig::Rec709g10, KisConfig::Rec709g22, 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