core: Add support for HDR and color management protocols (#8715)
This commit is contained in:
UjinT34
GitHub
parent
95542e4488
commit
830350a1f7
18 changed files with 3000 additions and 0 deletions
|
|
@ -31,6 +31,7 @@
|
|||
#include "protocols/XDGShell.hpp"
|
||||
#include "protocols/XDGOutput.hpp"
|
||||
#include "protocols/SecurityContext.hpp"
|
||||
#include "protocols/ColorManagement.hpp"
|
||||
#include "protocols/core/Compositor.hpp"
|
||||
#include "protocols/core/Subcompositor.hpp"
|
||||
#include "desktop/LayerSurface.hpp"
|
||||
|
|
@ -2985,4 +2986,22 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
|
|||
|
||||
g_pHyprRenderer->damageMonitor(PNEWMONITOR);
|
||||
PNEWMONITOR->onMonitorFrame();
|
||||
|
||||
if (PROTO::colorManagement && shouldChangePreferredImageDescription())
|
||||
PROTO::colorManagement->onImagePreferredChanged();
|
||||
}
|
||||
|
||||
SImageDescription CCompositor::getPreferredImageDescription() {
|
||||
if (!PROTO::colorManagement) {
|
||||
Debug::log(ERR, "FIXME: color management protocol is not enabled, returning empty image description");
|
||||
return SImageDescription{};
|
||||
}
|
||||
Debug::log(WARN, "FIXME: color management protocol is enabled, determine correct preferred image description");
|
||||
// should determine some common settings to avoid unnecessary transformations while keeping maximum displayable precision
|
||||
return SImageDescription{.primaries = NColorPrimaries::BT709};
|
||||
}
|
||||
|
||||
bool CCompositor::shouldChangePreferredImageDescription() {
|
||||
Debug::log(WARN, "FIXME: color management protocol is enabled and outputs changed, check preferred image description changes");
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include "helpers/Monitor.hpp"
|
||||
#include "desktop/Workspace.hpp"
|
||||
#include "desktop/Window.hpp"
|
||||
#include "protocols/types/ColorManagement.hpp"
|
||||
#include "render/Renderer.hpp"
|
||||
#include "render/OpenGL.hpp"
|
||||
#include "hyprerror/HyprError.hpp"
|
||||
|
|
@ -169,6 +170,9 @@ class CCompositor {
|
|||
void updateSuspendedStates();
|
||||
void onNewMonitor(SP<Aquamarine::IOutput> output);
|
||||
|
||||
SImageDescription getPreferredImageDescription();
|
||||
bool shouldChangePreferredImageDescription();
|
||||
|
||||
std::string explicitConfigPath;
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -1658,4 +1658,22 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
|
|||
.type = CONFIG_OPTION_BOOL,
|
||||
.data = SConfigOptionDescription::SBoolData{true},
|
||||
},
|
||||
SConfigOptionDescription{
|
||||
.value = "experimental:wide_color_gamut",
|
||||
.description = "force wide color gamut for all supported outputs",
|
||||
.type = CONFIG_OPTION_BOOL,
|
||||
.data = SConfigOptionDescription::SBoolData{false},
|
||||
},
|
||||
SConfigOptionDescription{
|
||||
.value = "experimental:hdr",
|
||||
.description = "force static hdr for all supported outputs",
|
||||
.type = CONFIG_OPTION_BOOL,
|
||||
.data = SConfigOptionDescription::SBoolData{false},
|
||||
},
|
||||
SConfigOptionDescription{
|
||||
.value = "experimental:xx_color_management_v4",
|
||||
.description = "enable color management protocol",
|
||||
.type = CONFIG_OPTION_BOOL,
|
||||
.data = SConfigOptionDescription::SBoolData{false},
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -622,6 +622,10 @@ CConfigManager::CConfigManager() {
|
|||
|
||||
m_pConfig->addConfigValue("ecosystem:no_update_news", Hyprlang::INT{0});
|
||||
|
||||
m_pConfig->addConfigValue("experimental:wide_color_gamut", Hyprlang::INT{0});
|
||||
m_pConfig->addConfigValue("experimental:hdr", Hyprlang::INT{0});
|
||||
m_pConfig->addConfigValue("experimental:xx_color_management_v4", Hyprlang::INT{0});
|
||||
|
||||
// devices
|
||||
m_pConfig->addSpecialCategory("device", {"name"});
|
||||
m_pConfig->addSpecialConfigValue("device", "sensitivity", {0.F});
|
||||
|
|
|
|||
|
|
@ -119,4 +119,5 @@ class CWLSurface {
|
|||
} listeners;
|
||||
|
||||
friend class CPointerConstraint;
|
||||
friend class CXxColorManagerV4;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@
|
|||
#include "../protocols/core/Subcompositor.hpp"
|
||||
#include "../protocols/core/Output.hpp"
|
||||
#include "../protocols/core/Shm.hpp"
|
||||
#include "../protocols/ColorManagement.hpp"
|
||||
#include "../protocols/FrogColorManagement.hpp"
|
||||
|
||||
#include "../helpers/Monitor.hpp"
|
||||
#include "../render/Renderer.hpp"
|
||||
|
|
@ -77,11 +79,15 @@ void CProtocolManager::onMonitorModeChange(PHLMONITOR pMonitor) {
|
|||
PROTO::outputs.erase(pMonitor->szName);
|
||||
PROTO::outputs.emplace(pMonitor->szName, makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", pMonitor->szName), pMonitor->self.lock()));
|
||||
}
|
||||
|
||||
if (PROTO::colorManagement && g_pCompositor->shouldChangePreferredImageDescription())
|
||||
PROTO::colorManagement->onImagePreferredChanged();
|
||||
}
|
||||
|
||||
CProtocolManager::CProtocolManager() {
|
||||
|
||||
static const auto PENABLEEXPLICIT = CConfigValue<Hyprlang::INT>("render:explicit_sync");
|
||||
static const auto PENABLEXXCM = CConfigValue<Hyprlang::INT>("experimental:xx_color_management_v4");
|
||||
|
||||
// Outputs are a bit dumb, we have to agree.
|
||||
static auto P = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any param) {
|
||||
|
|
@ -162,6 +168,11 @@ CProtocolManager::CProtocolManager() {
|
|||
PROTO::ctm = std::make_unique<CHyprlandCTMControlProtocol>(&hyprland_ctm_control_manager_v1_interface, 1, "CTMControl");
|
||||
PROTO::hyprlandSurface = std::make_unique<CHyprlandSurfaceProtocol>(&hyprland_surface_manager_v1_interface, 1, "HyprlandSurface");
|
||||
|
||||
if (*PENABLEXXCM) {
|
||||
PROTO::colorManagement = std::make_unique<CColorManagementProtocol>(&xx_color_manager_v4_interface, 1, "ColorManagement");
|
||||
PROTO::frogColorManagement = std::make_unique<CFrogColorManagementProtocol>(&frog_color_management_factory_v1_interface, 1, "FrogColorManagement");
|
||||
}
|
||||
|
||||
for (auto const& b : g_pCompositor->m_pAqBackend->getImplementations()) {
|
||||
if (b->type() != Aquamarine::AQ_BACKEND_DRM)
|
||||
continue;
|
||||
|
|
|
|||
571
src/protocols/ColorManagement.cpp
Normal file
571
src/protocols/ColorManagement.cpp
Normal file
|
|
@ -0,0 +1,571 @@
|
|||
#include "ColorManagement.hpp"
|
||||
#include "Compositor.hpp"
|
||||
|
||||
CColorManager::CColorManager(SP<CXxColorManagerV4> resource_) : resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
resource->sendSupportedFeature(XX_COLOR_MANAGER_V4_FEATURE_PARAMETRIC);
|
||||
resource->sendSupportedFeature(XX_COLOR_MANAGER_V4_FEATURE_EXTENDED_TARGET_VOLUME);
|
||||
resource->sendSupportedFeature(XX_COLOR_MANAGER_V4_FEATURE_SET_MASTERING_DISPLAY_PRIMARIES);
|
||||
resource->sendSupportedFeature(XX_COLOR_MANAGER_V4_FEATURE_SET_PRIMARIES);
|
||||
resource->sendSupportedFeature(XX_COLOR_MANAGER_V4_FEATURE_SET_LUMINANCES);
|
||||
|
||||
resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_SRGB);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_PAL_M);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_PAL);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_NTSC);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_GENERIC_FILM);
|
||||
resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_BT2020);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_CIE1931_XYZ);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_DCI_P3);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_DISPLAY_P3);
|
||||
// resource->sendSupportedPrimariesNamed(XX_COLOR_MANAGER_V4_PRIMARIES_ADOBE_RGB);
|
||||
|
||||
// resource->sendSupportedTfNamed(XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_GAMMA22);
|
||||
resource->sendSupportedTfNamed(XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_SRGB);
|
||||
resource->sendSupportedTfNamed(XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_ST2084_PQ);
|
||||
// resource->sendSupportedTfNamed(XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_LINEAR);
|
||||
|
||||
resource->sendSupportedIntent(XX_COLOR_MANAGER_V4_RENDER_INTENT_PERCEPTUAL);
|
||||
// resource->sendSupportedIntent(XX_COLOR_MANAGER_V4_RENDER_INTENT_RELATIVE);
|
||||
// resource->sendSupportedIntent(XX_COLOR_MANAGER_V4_RENDER_INTENT_ABSOLUTE);
|
||||
// resource->sendSupportedIntent(XX_COLOR_MANAGER_V4_RENDER_INTENT_RELATIVE_BPC);
|
||||
|
||||
resource->setDestroy([](CXxColorManagerV4* r) { LOGM(TRACE, "Destroy xx_color_manager at {:x} (generated default)", (uintptr_t)r); });
|
||||
resource->setGetOutput([](CXxColorManagerV4* r, uint32_t id, wl_resource* output) {
|
||||
LOGM(TRACE, "Get output for id={}, output={}", id, (uintptr_t)output);
|
||||
const auto RESOURCE =
|
||||
PROTO::colorManagement->m_vOutputs.emplace_back(makeShared<CColorManagementOutput>(makeShared<CXxColorManagementOutputV4>(r->client(), r->version(), id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vOutputs.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
});
|
||||
resource->setGetSurface([](CXxColorManagerV4* r, uint32_t id, wl_resource* surface) {
|
||||
LOGM(TRACE, "Get surface for id={}, surface={}", id, (uintptr_t)surface);
|
||||
auto SURF = CWLSurfaceResource::fromResource(surface);
|
||||
|
||||
if (!SURF) {
|
||||
LOGM(ERR, "No surface for resource {}", (uintptr_t)surface);
|
||||
r->error(-1, "Invalid surface (2)");
|
||||
return;
|
||||
}
|
||||
|
||||
if (SURF->colorManagement) {
|
||||
r->error(XX_COLOR_MANAGER_V4_ERROR_SURFACE_EXISTS, "CM Surface already exists");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto RESOURCE =
|
||||
PROTO::colorManagement->m_vSurfaces.emplace_back(makeShared<CColorManagementSurface>(makeShared<CXxColorManagementSurfaceV4>(r->client(), r->version(), id), SURF));
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vSurfaces.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
|
||||
SURF->colorManagement = RESOURCE;
|
||||
});
|
||||
resource->setGetFeedbackSurface([](CXxColorManagerV4* r, uint32_t id, wl_resource* surface) {
|
||||
LOGM(TRACE, "Get feedback surface for id={}, surface={}", id, (uintptr_t)surface);
|
||||
auto SURF = CWLSurfaceResource::fromResource(surface);
|
||||
|
||||
if (!SURF) {
|
||||
LOGM(ERR, "No surface for resource {}", (uintptr_t)surface);
|
||||
r->error(-1, "Invalid surface (2)");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vFeedbackSurfaces.emplace_back(
|
||||
makeShared<CColorManagementFeedbackSurface>(makeShared<CXxColorManagementFeedbackSurfaceV4>(r->client(), r->version(), id), SURF));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vFeedbackSurfaces.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
});
|
||||
resource->setNewIccCreator([](CXxColorManagerV4* r, uint32_t id) {
|
||||
LOGM(WARN, "New ICC creator for id={} (unsupported)", id);
|
||||
r->error(XX_COLOR_MANAGER_V4_ERROR_UNSUPPORTED_FEATURE, "ICC profiles are not supported");
|
||||
});
|
||||
resource->setNewParametricCreator([](CXxColorManagerV4* r, uint32_t id) {
|
||||
LOGM(TRACE, "New parametric creator for id={}", id);
|
||||
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vParametricCreators.emplace_back(
|
||||
makeShared<CColorManagementParametricCreator>(makeShared<CXxImageDescriptionCreatorParamsV4>(r->client(), r->version(), id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vParametricCreators.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
});
|
||||
|
||||
resource->setOnDestroy([this](CXxColorManagerV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
}
|
||||
|
||||
bool CColorManager::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
CColorManagementOutput::CColorManagementOutput(SP<CXxColorManagementOutputV4> resource_) : resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = resource->client();
|
||||
|
||||
resource->setDestroy([this](CXxColorManagementOutputV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
resource->setOnDestroy([this](CXxColorManagementOutputV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
|
||||
resource->setGetImageDescription([this](CXxColorManagementOutputV4* r, uint32_t id) {
|
||||
LOGM(TRACE, "Get image description for output={}, id={}", (uintptr_t)r, id);
|
||||
if (imageDescription.valid())
|
||||
PROTO::colorManagement->destroyResource(imageDescription.get());
|
||||
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vImageDescriptions.emplace_back(
|
||||
makeShared<CColorManagementImageDescription>(makeShared<CXxImageDescriptionV4>(r->client(), r->version(), id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vImageDescriptions.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
});
|
||||
}
|
||||
|
||||
bool CColorManagementOutput::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementOutput::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
CColorManagementSurface::CColorManagementSurface(SP<CWLSurfaceResource> surface_) : surface(surface_) {
|
||||
// only for frog cm untill wayland cm is adopted
|
||||
}
|
||||
|
||||
CColorManagementSurface::CColorManagementSurface(SP<CXxColorManagementSurfaceV4> resource_, SP<CWLSurfaceResource> surface_) : surface(surface_), resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = resource->client();
|
||||
|
||||
resource->setDestroy([this](CXxColorManagementSurfaceV4* r) {
|
||||
LOGM(TRACE, "Destroy xx cm surface {}", (uintptr_t)surface);
|
||||
PROTO::colorManagement->destroyResource(this);
|
||||
});
|
||||
resource->setOnDestroy([this](CXxColorManagementSurfaceV4* r) {
|
||||
LOGM(TRACE, "Destroy xx cm surface {}", (uintptr_t)surface);
|
||||
PROTO::colorManagement->destroyResource(this);
|
||||
});
|
||||
|
||||
resource->setSetImageDescription([this](CXxColorManagementSurfaceV4* r, wl_resource* image_description, uint32_t render_intent) {
|
||||
LOGM(TRACE, "Set image description for surface={}, desc={}, intent={}", (uintptr_t)r, (uintptr_t)image_description, render_intent);
|
||||
|
||||
const auto PO = (CXxImageDescriptionV4*)wl_resource_get_user_data(image_description);
|
||||
if (!PO) { // FIXME check validity
|
||||
r->error(XX_COLOR_MANAGEMENT_SURFACE_V4_ERROR_IMAGE_DESCRIPTION, "Image description creation failed");
|
||||
return;
|
||||
}
|
||||
if (render_intent != XX_COLOR_MANAGER_V4_RENDER_INTENT_PERCEPTUAL) {
|
||||
r->error(XX_COLOR_MANAGEMENT_SURFACE_V4_ERROR_RENDER_INTENT, "Unsupported render intent");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto imageDescription = std::find_if(PROTO::colorManagement->m_vImageDescriptions.begin(), PROTO::colorManagement->m_vImageDescriptions.end(),
|
||||
[&](const auto& other) { return other->resource()->resource() == image_description; });
|
||||
if (imageDescription == PROTO::colorManagement->m_vImageDescriptions.end()) {
|
||||
r->error(XX_COLOR_MANAGEMENT_SURFACE_V4_ERROR_IMAGE_DESCRIPTION, "Image description not found");
|
||||
return;
|
||||
}
|
||||
|
||||
m_hasImageDescription = true;
|
||||
m_imageDescription = imageDescription->get()->settings;
|
||||
});
|
||||
resource->setUnsetImageDescription([this](CXxColorManagementSurfaceV4* r) {
|
||||
LOGM(TRACE, "Unset image description for surface={}", (uintptr_t)r);
|
||||
m_imageDescription = SImageDescription{};
|
||||
m_hasImageDescription = false;
|
||||
});
|
||||
}
|
||||
|
||||
bool CColorManagementSurface::good() {
|
||||
return resource && resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementSurface::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
const SImageDescription& CColorManagementSurface::imageDescription() {
|
||||
if (!hasImageDescription())
|
||||
LOGM(WARN, "Reading imageDescription while none set. Returns default or empty values");
|
||||
return m_imageDescription;
|
||||
}
|
||||
|
||||
bool CColorManagementSurface::hasImageDescription() {
|
||||
return m_hasImageDescription;
|
||||
}
|
||||
|
||||
CColorManagementFeedbackSurface::CColorManagementFeedbackSurface(SP<CXxColorManagementFeedbackSurfaceV4> resource_, SP<CWLSurfaceResource> surface_) :
|
||||
surface(surface_), resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = resource->client();
|
||||
|
||||
resource->setDestroy([this](CXxColorManagementFeedbackSurfaceV4* r) {
|
||||
LOGM(TRACE, "Destroy xx cm feedback surface {}", (uintptr_t)surface);
|
||||
if (m_currentPreferred.valid())
|
||||
PROTO::colorManagement->destroyResource(m_currentPreferred.get());
|
||||
PROTO::colorManagement->destroyResource(this);
|
||||
});
|
||||
resource->setOnDestroy([this](CXxColorManagementFeedbackSurfaceV4* r) {
|
||||
LOGM(TRACE, "Destroy xx cm feedback surface {}", (uintptr_t)surface);
|
||||
if (m_currentPreferred.valid())
|
||||
PROTO::colorManagement->destroyResource(m_currentPreferred.get());
|
||||
PROTO::colorManagement->destroyResource(this);
|
||||
});
|
||||
|
||||
resource->setGetPreferred([this](CXxColorManagementFeedbackSurfaceV4* r, uint32_t id) {
|
||||
LOGM(TRACE, "Get preferred for id {}", id);
|
||||
|
||||
if (m_currentPreferred.valid())
|
||||
PROTO::colorManagement->destroyResource(m_currentPreferred.get());
|
||||
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vImageDescriptions.emplace_back(
|
||||
makeShared<CColorManagementImageDescription>(makeShared<CXxImageDescriptionV4>(r->client(), r->version(), id), true));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vImageDescriptions.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
m_currentPreferred = RESOURCE;
|
||||
|
||||
m_currentPreferred->settings = g_pCompositor->getPreferredImageDescription();
|
||||
|
||||
RESOURCE->resource()->sendReady(id);
|
||||
});
|
||||
}
|
||||
|
||||
bool CColorManagementFeedbackSurface::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementFeedbackSurface::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
CColorManagementParametricCreator::CColorManagementParametricCreator(SP<CXxImageDescriptionCreatorParamsV4> resource_) : resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
//
|
||||
pClient = resource->client();
|
||||
|
||||
resource->setOnDestroy([this](CXxImageDescriptionCreatorParamsV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
|
||||
resource->setCreate([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t id) {
|
||||
LOGM(TRACE, "Create image description from params for id {}", id);
|
||||
|
||||
// FIXME actually check completeness
|
||||
if (!valuesSet) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INCOMPLETE_SET, "Missing required settings");
|
||||
return;
|
||||
}
|
||||
|
||||
// FIXME actually check consistency
|
||||
if (!valuesSet) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INCONSISTENT_SET, "Set is not consistent");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vImageDescriptions.emplace_back(
|
||||
makeShared<CColorManagementImageDescription>(makeShared<CXxImageDescriptionV4>(r->client(), r->version(), id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::colorManagement->m_vImageDescriptions.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
// FIXME actually check support
|
||||
if (!valuesSet) {
|
||||
RESOURCE->resource()->sendFailed(XX_IMAGE_DESCRIPTION_V4_CAUSE_UNSUPPORTED, "unsupported");
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
RESOURCE->settings = settings;
|
||||
RESOURCE->resource()->sendReady(id);
|
||||
|
||||
PROTO::colorManagement->destroyResource(this);
|
||||
});
|
||||
resource->setSetTfNamed([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t tf) {
|
||||
LOGM(TRACE, "Set image description transfer function to {}", tf);
|
||||
if (valuesSet & PC_TF) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Transfer function already set");
|
||||
return;
|
||||
}
|
||||
|
||||
switch (tf) {
|
||||
case XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_SRGB: break;
|
||||
case XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_ST2084_PQ: break;
|
||||
default: r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INVALID_TF, "Unsupported transfer function"); return;
|
||||
}
|
||||
|
||||
settings.transferFunction = (xxColorManagerV4TransferFunction)tf;
|
||||
valuesSet |= PC_TF;
|
||||
});
|
||||
resource->setSetTfPower([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t eexp) {
|
||||
LOGM(TRACE, "Set image description tf power to {}", eexp);
|
||||
if (valuesSet & PC_TF_POWER) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Transfer function power already set");
|
||||
return;
|
||||
}
|
||||
settings.transferFunctionPower = eexp / 10000.0f;
|
||||
valuesSet |= PC_TF_POWER;
|
||||
});
|
||||
resource->setSetPrimariesNamed([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t primaries) {
|
||||
LOGM(TRACE, "Set image description primaries by name {}", primaries);
|
||||
if (valuesSet & PC_PRIMARIES) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Primaries already set");
|
||||
return;
|
||||
}
|
||||
|
||||
switch (primaries) {
|
||||
case XX_COLOR_MANAGER_V4_PRIMARIES_SRGB:
|
||||
settings.primariesNameSet = true;
|
||||
settings.primariesNamed = XX_COLOR_MANAGER_V4_PRIMARIES_SRGB;
|
||||
settings.primaries = NColorPrimaries::BT709;
|
||||
valuesSet |= PC_PRIMARIES;
|
||||
break;
|
||||
case XX_COLOR_MANAGER_V4_PRIMARIES_BT2020:
|
||||
settings.primariesNameSet = true;
|
||||
settings.primariesNamed = XX_COLOR_MANAGER_V4_PRIMARIES_BT2020;
|
||||
settings.primaries = NColorPrimaries::BT2020;
|
||||
valuesSet |= PC_PRIMARIES;
|
||||
break;
|
||||
default: r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INVALID_PRIMARIES, "Unsupported primaries");
|
||||
}
|
||||
});
|
||||
resource->setSetPrimaries(
|
||||
[this](CXxImageDescriptionCreatorParamsV4* r, int32_t r_x, int32_t r_y, int32_t g_x, int32_t g_y, int32_t b_x, int32_t b_y, int32_t w_x, int32_t w_y) {
|
||||
LOGM(TRACE, "Set image description primaries by values r:{},{} g:{},{} b:{},{} w:{},{}", r_x, r_y, g_x, g_y, b_x, b_y, w_x, w_y);
|
||||
if (valuesSet & PC_PRIMARIES) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Primaries already set");
|
||||
return;
|
||||
}
|
||||
settings.primariesNameSet = false;
|
||||
settings.primaries =
|
||||
SImageDescription::SPCPRimaries{.red = {.x = r_x, .y = r_y}, .green = {.x = g_x, .y = g_y}, .blue = {.x = b_x, .y = b_y}, .white = {.x = w_x, .y = w_y}};
|
||||
valuesSet |= PC_PRIMARIES;
|
||||
});
|
||||
resource->setSetLuminances([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t min_lum, uint32_t max_lum, uint32_t reference_lum) {
|
||||
auto min = min_lum / 10000.0f;
|
||||
LOGM(TRACE, "Set image description luminances to {} - {} ({})", min, max_lum, reference_lum);
|
||||
if (valuesSet & PC_LUMINANCES) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Luminances already set");
|
||||
return;
|
||||
}
|
||||
if (max_lum < reference_lum || reference_lum <= min) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INVALID_LUMINANCE, "Invalid luminances");
|
||||
return;
|
||||
}
|
||||
settings.luminances = SImageDescription::SPCLuminances{.min = min, .max = max_lum, .reference = reference_lum};
|
||||
valuesSet |= PC_LUMINANCES;
|
||||
});
|
||||
resource->setSetMasteringDisplayPrimaries(
|
||||
[this](CXxImageDescriptionCreatorParamsV4* r, int32_t r_x, int32_t r_y, int32_t g_x, int32_t g_y, int32_t b_x, int32_t b_y, int32_t w_x, int32_t w_y) {
|
||||
LOGM(TRACE, "Set image description mastering primaries by values r:{},{} g:{},{} b:{},{} w:{},{}", r_x, r_y, g_x, g_y, b_x, b_y, w_x, w_y);
|
||||
// if (valuesSet & PC_MASTERING_PRIMARIES) {
|
||||
// r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Mastering primaries already set");
|
||||
// return;
|
||||
// }
|
||||
settings.masteringPrimaries =
|
||||
SImageDescription::SPCPRimaries{.red = {.x = r_x, .y = r_y}, .green = {.x = g_x, .y = g_y}, .blue = {.x = b_x, .y = b_y}, .white = {.x = w_x, .y = w_y}};
|
||||
valuesSet |= PC_MASTERING_PRIMARIES;
|
||||
});
|
||||
resource->setSetMasteringLuminance([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t min_lum, uint32_t max_lum) {
|
||||
auto min = min_lum / 10000.0f;
|
||||
LOGM(TRACE, "Set image description mastering luminances to {} - {}", min, max_lum);
|
||||
// if (valuesSet & PC_MASTERING_LUMINANCES) {
|
||||
// r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Mastering luminances already set");
|
||||
// return;
|
||||
// }
|
||||
if (min > 0 && max_lum > 0 && max_lum <= min) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_INVALID_LUMINANCE, "Invalid luminances");
|
||||
return;
|
||||
}
|
||||
settings.masteringLuminances = SImageDescription::SPCMasteringLuminances{.min = min, .max = max_lum};
|
||||
valuesSet |= PC_MASTERING_LUMINANCES;
|
||||
});
|
||||
resource->setSetMaxCll([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t max_cll) {
|
||||
LOGM(TRACE, "Set image description max content light level to {}", max_cll);
|
||||
// if (valuesSet & PC_CLL) {
|
||||
// r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Max CLL already set");
|
||||
// return;
|
||||
// }
|
||||
settings.maxCLL = max_cll;
|
||||
valuesSet |= PC_CLL;
|
||||
});
|
||||
resource->setSetMaxFall([this](CXxImageDescriptionCreatorParamsV4* r, uint32_t max_fall) {
|
||||
LOGM(TRACE, "Set image description max frame-average light level to {}", max_fall);
|
||||
// if (valuesSet & PC_FALL) {
|
||||
// r->error(XX_IMAGE_DESCRIPTION_CREATOR_PARAMS_V4_ERROR_ALREADY_SET, "Max FALL already set");
|
||||
// return;
|
||||
// }
|
||||
settings.maxFALL = max_fall;
|
||||
valuesSet |= PC_FALL;
|
||||
});
|
||||
}
|
||||
|
||||
bool CColorManagementParametricCreator::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementParametricCreator::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
CColorManagementImageDescription::CColorManagementImageDescription(SP<CXxImageDescriptionV4> resource_, bool allowGetInformation) :
|
||||
m_resource(resource_), m_allowGetInformation(allowGetInformation) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = m_resource->client();
|
||||
|
||||
m_resource->setDestroy([this](CXxImageDescriptionV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
m_resource->setOnDestroy([this](CXxImageDescriptionV4* r) { PROTO::colorManagement->destroyResource(this); });
|
||||
|
||||
m_resource->setGetInformation([this](CXxImageDescriptionV4* r, uint32_t id) {
|
||||
LOGM(TRACE, "Get image information for image={}, id={}", (uintptr_t)r, id);
|
||||
if (!m_allowGetInformation) {
|
||||
r->error(XX_IMAGE_DESCRIPTION_V4_ERROR_NO_INFORMATION, "Image descriptions doesn't allow get_information request");
|
||||
return;
|
||||
}
|
||||
|
||||
auto RESOURCE = makeShared<CColorManagementImageDescriptionInfo>(makeShared<CXxImageDescriptionInfoV4>(r->client(), r->version(), id), settings);
|
||||
|
||||
if (!RESOURCE->good())
|
||||
r->noMemory();
|
||||
|
||||
// CColorManagementImageDescriptionInfo should send everything in the constructor and be ready for destroying at this point
|
||||
RESOURCE.reset();
|
||||
});
|
||||
}
|
||||
|
||||
bool CColorManagementImageDescription::good() {
|
||||
return m_resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementImageDescription::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
SP<CXxImageDescriptionV4> CColorManagementImageDescription::resource() {
|
||||
return m_resource;
|
||||
}
|
||||
|
||||
CColorManagementImageDescriptionInfo::CColorManagementImageDescriptionInfo(SP<CXxImageDescriptionInfoV4> resource_, const SImageDescription& settings_) :
|
||||
m_resource(resource_), settings(settings_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = m_resource->client();
|
||||
|
||||
const auto toProto = [](float value) { return int32_t(std::round(value * 10000)); };
|
||||
|
||||
if (settings.iccFd >= 0)
|
||||
m_resource->sendIccFile(settings.iccFd, settings.iccSize);
|
||||
|
||||
// send preferred client paramateres
|
||||
m_resource->sendPrimaries(toProto(settings.primaries.red.x), toProto(settings.primaries.red.y), toProto(settings.primaries.green.x), toProto(settings.primaries.green.y),
|
||||
toProto(settings.primaries.blue.x), toProto(settings.primaries.blue.y), toProto(settings.primaries.white.x), toProto(settings.primaries.white.y));
|
||||
if (settings.primariesNameSet)
|
||||
m_resource->sendPrimariesNamed(settings.primariesNamed);
|
||||
m_resource->sendTfPower(std::round(settings.transferFunctionPower * 10000));
|
||||
m_resource->sendTfNamed(settings.transferFunction);
|
||||
m_resource->sendLuminances(std::round(settings.luminances.min * 10000), settings.luminances.max, settings.luminances.reference);
|
||||
|
||||
// send expexted display paramateres
|
||||
m_resource->sendTargetPrimaries(toProto(settings.masteringPrimaries.red.x), toProto(settings.masteringPrimaries.red.y), toProto(settings.masteringPrimaries.green.x),
|
||||
toProto(settings.masteringPrimaries.green.y), toProto(settings.masteringPrimaries.blue.x), toProto(settings.masteringPrimaries.blue.y),
|
||||
toProto(settings.masteringPrimaries.white.x), toProto(settings.masteringPrimaries.white.y));
|
||||
m_resource->sendTargetLuminance(std::round(settings.masteringLuminances.min * 10000), settings.masteringLuminances.max);
|
||||
m_resource->sendTargetMaxCll(settings.maxCLL);
|
||||
m_resource->sendTargetMaxFall(settings.maxFALL);
|
||||
|
||||
m_resource->sendDone();
|
||||
}
|
||||
|
||||
bool CColorManagementImageDescriptionInfo::good() {
|
||||
return m_resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CColorManagementImageDescriptionInfo::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
CColorManagementProtocol::CColorManagementProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
|
||||
;
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
|
||||
const auto RESOURCE = m_vManagers.emplace_back(makeShared<CColorManager>(makeShared<CXxColorManagerV4>(client, ver, id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
wl_client_post_no_memory(client);
|
||||
m_vManagers.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
LOGM(TRACE, "New xx_color_manager at {:x}", (uintptr_t)RESOURCE.get());
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::onImagePreferredChanged() {
|
||||
for (auto const& feedback : m_vFeedbackSurfaces) {
|
||||
feedback->resource->sendPreferredChanged();
|
||||
}
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManager* resource) {
|
||||
std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManagementOutput* resource) {
|
||||
std::erase_if(m_vOutputs, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManagementSurface* resource) {
|
||||
std::erase_if(m_vSurfaces, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManagementFeedbackSurface* resource) {
|
||||
std::erase_if(m_vFeedbackSurfaces, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManagementParametricCreator* resource) {
|
||||
std::erase_if(m_vParametricCreators, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CColorManagementProtocol::destroyResource(CColorManagementImageDescription* resource) {
|
||||
std::erase_if(m_vImageDescriptions, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
182
src/protocols/ColorManagement.hpp
Normal file
182
src/protocols/ColorManagement.hpp
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <cstdint>
|
||||
#include "WaylandProtocol.hpp"
|
||||
#include "protocols/core/Compositor.hpp"
|
||||
#include "xx-color-management-v4.hpp"
|
||||
#include "types/ColorManagement.hpp"
|
||||
|
||||
class CColorManager;
|
||||
class CColorManagementOutput;
|
||||
class CColorManagementImageDescription;
|
||||
class CColorManagementProtocol;
|
||||
|
||||
class CColorManager {
|
||||
public:
|
||||
CColorManager(SP<CXxColorManagerV4> resource_);
|
||||
|
||||
bool good();
|
||||
|
||||
private:
|
||||
SP<CXxColorManagerV4> resource;
|
||||
};
|
||||
|
||||
class CColorManagementOutput {
|
||||
public:
|
||||
CColorManagementOutput(SP<CXxColorManagementOutputV4> resource_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
WP<CColorManagementOutput> self;
|
||||
WP<CColorManagementImageDescription> imageDescription;
|
||||
|
||||
private:
|
||||
SP<CXxColorManagementOutputV4> resource;
|
||||
wl_client* pClient = nullptr;
|
||||
|
||||
friend class CColorManagementProtocol;
|
||||
friend class CColorManagementImageDescription;
|
||||
};
|
||||
|
||||
class CColorManagementSurface {
|
||||
public:
|
||||
CColorManagementSurface(SP<CWLSurfaceResource> surface_); // temporary interface for frog CM
|
||||
CColorManagementSurface(SP<CXxColorManagementSurfaceV4> resource_, SP<CWLSurfaceResource> surface_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
WP<CColorManagementSurface> self;
|
||||
WP<CWLSurfaceResource> surface;
|
||||
|
||||
const SImageDescription& imageDescription();
|
||||
bool hasImageDescription();
|
||||
|
||||
private:
|
||||
SP<CXxColorManagementSurfaceV4> resource;
|
||||
wl_client* pClient = nullptr;
|
||||
SImageDescription m_imageDescription;
|
||||
bool m_hasImageDescription = false;
|
||||
|
||||
friend class CFrogColorManagementSurface;
|
||||
};
|
||||
|
||||
class CColorManagementFeedbackSurface {
|
||||
public:
|
||||
CColorManagementFeedbackSurface(SP<CXxColorManagementFeedbackSurfaceV4> resource_, SP<CWLSurfaceResource> surface_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
WP<CColorManagementFeedbackSurface> self;
|
||||
WP<CWLSurfaceResource> surface;
|
||||
|
||||
private:
|
||||
SP<CXxColorManagementFeedbackSurfaceV4> resource;
|
||||
wl_client* pClient = nullptr;
|
||||
|
||||
WP<CColorManagementImageDescription> m_currentPreferred;
|
||||
|
||||
friend class CColorManagementProtocol;
|
||||
};
|
||||
|
||||
class CColorManagementParametricCreator {
|
||||
public:
|
||||
CColorManagementParametricCreator(SP<CXxImageDescriptionCreatorParamsV4> resource_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
WP<CColorManagementParametricCreator> self;
|
||||
|
||||
SImageDescription settings;
|
||||
|
||||
private:
|
||||
enum eValuesSet : uint32_t { // NOLINT
|
||||
PC_TF = (1 << 0),
|
||||
PC_TF_POWER = (1 << 1),
|
||||
PC_PRIMARIES = (1 << 2),
|
||||
PC_LUMINANCES = (1 << 3),
|
||||
PC_MASTERING_PRIMARIES = (1 << 4),
|
||||
PC_MASTERING_LUMINANCES = (1 << 5),
|
||||
PC_CLL = (1 << 6),
|
||||
PC_FALL = (1 << 7),
|
||||
};
|
||||
|
||||
SP<CXxImageDescriptionCreatorParamsV4> resource;
|
||||
wl_client* pClient = nullptr;
|
||||
uint32_t valuesSet = 0; // enum eValuesSet
|
||||
};
|
||||
|
||||
class CColorManagementImageDescription {
|
||||
public:
|
||||
CColorManagementImageDescription(SP<CXxImageDescriptionV4> resource_, bool allowGetInformation = false);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
SP<CXxImageDescriptionV4> resource();
|
||||
|
||||
WP<CColorManagementImageDescription> self;
|
||||
|
||||
SImageDescription settings;
|
||||
|
||||
private:
|
||||
SP<CXxImageDescriptionV4> m_resource;
|
||||
wl_client* pClient = nullptr;
|
||||
bool m_allowGetInformation = false;
|
||||
|
||||
friend class CColorManagementOutput;
|
||||
};
|
||||
|
||||
class CColorManagementImageDescriptionInfo {
|
||||
public:
|
||||
CColorManagementImageDescriptionInfo(SP<CXxImageDescriptionInfoV4> resource_, const SImageDescription& settings_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
private:
|
||||
SP<CXxImageDescriptionInfoV4> m_resource;
|
||||
wl_client* pClient = nullptr;
|
||||
SImageDescription settings;
|
||||
};
|
||||
|
||||
class CColorManagementProtocol : public IWaylandProtocol {
|
||||
public:
|
||||
CColorManagementProtocol(const wl_interface* iface, const int& ver, const std::string& name);
|
||||
|
||||
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
|
||||
|
||||
void onImagePreferredChanged();
|
||||
|
||||
private:
|
||||
void destroyResource(CColorManager* resource);
|
||||
void destroyResource(CColorManagementOutput* resource);
|
||||
void destroyResource(CColorManagementSurface* resource);
|
||||
void destroyResource(CColorManagementFeedbackSurface* resource);
|
||||
void destroyResource(CColorManagementParametricCreator* resource);
|
||||
void destroyResource(CColorManagementImageDescription* resource);
|
||||
|
||||
std::vector<SP<CColorManager>> m_vManagers;
|
||||
std::vector<SP<CColorManagementOutput>> m_vOutputs;
|
||||
std::vector<SP<CColorManagementSurface>> m_vSurfaces;
|
||||
std::vector<SP<CColorManagementFeedbackSurface>> m_vFeedbackSurfaces;
|
||||
std::vector<SP<CColorManagementParametricCreator>> m_vParametricCreators;
|
||||
std::vector<SP<CColorManagementImageDescription>> m_vImageDescriptions;
|
||||
|
||||
friend class CColorManager;
|
||||
friend class CColorManagementOutput;
|
||||
friend class CColorManagementSurface;
|
||||
friend class CColorManagementFeedbackSurface;
|
||||
friend class CColorManagementParametricCreator;
|
||||
friend class CColorManagementImageDescription;
|
||||
|
||||
friend class CFrogColorManagementSurface;
|
||||
};
|
||||
|
||||
namespace PROTO {
|
||||
inline UP<CColorManagementProtocol> colorManagement;
|
||||
};
|
||||
159
src/protocols/FrogColorManagement.cpp
Normal file
159
src/protocols/FrogColorManagement.cpp
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
#include "FrogColorManagement.hpp"
|
||||
#include "protocols/ColorManagement.hpp"
|
||||
#include "protocols/core/Subcompositor.hpp"
|
||||
|
||||
CFrogColorManager::CFrogColorManager(SP<CFrogColorManagementFactoryV1> resource_) : resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
resource->setDestroy([](CFrogColorManagementFactoryV1* r) { LOGM(TRACE, "Destroy frog_color_management at {:x} (generated default)", (uintptr_t)r); });
|
||||
resource->setOnDestroy([this](CFrogColorManagementFactoryV1* r) { PROTO::frogColorManagement->destroyResource(this); });
|
||||
|
||||
resource->setGetColorManagedSurface([](CFrogColorManagementFactoryV1* r, wl_resource* surface, uint32_t id) {
|
||||
LOGM(TRACE, "Get surface for id={}, surface={}", id, (uintptr_t)surface);
|
||||
auto SURF = CWLSurfaceResource::fromResource(surface);
|
||||
|
||||
if (!SURF) {
|
||||
LOGM(ERR, "No surface for resource {}", (uintptr_t)surface);
|
||||
r->error(-1, "Invalid surface (2)");
|
||||
return;
|
||||
}
|
||||
|
||||
if (SURF->role->role() == SURFACE_ROLE_SUBSURFACE)
|
||||
SURF = ((CSubsurfaceRole*)SURF->role.get())->subsurface->t1Parent();
|
||||
|
||||
const auto RESOURCE = PROTO::frogColorManagement->m_vSurfaces.emplace_back(
|
||||
makeShared<CFrogColorManagementSurface>(makeShared<CFrogColorManagedSurface>(r->client(), r->version(), id), SURF));
|
||||
if (!RESOURCE->good()) {
|
||||
r->noMemory();
|
||||
PROTO::frogColorManagement->m_vSurfaces.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
});
|
||||
}
|
||||
|
||||
bool CFrogColorManager::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
CFrogColorManagementSurface::CFrogColorManagementSurface(SP<CFrogColorManagedSurface> resource_, SP<CWLSurfaceResource> surface_) : surface(surface_), resource(resource_) {
|
||||
if (!good())
|
||||
return;
|
||||
|
||||
pClient = resource->client();
|
||||
|
||||
if (!surface->colorManagement.valid()) {
|
||||
const auto RESOURCE = PROTO::colorManagement->m_vSurfaces.emplace_back(makeShared<CColorManagementSurface>(surface_));
|
||||
if (!RESOURCE) {
|
||||
resource->noMemory();
|
||||
PROTO::colorManagement->m_vSurfaces.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
RESOURCE->self = RESOURCE;
|
||||
|
||||
surface->colorManagement = RESOURCE;
|
||||
|
||||
resource->setOnDestroy([this](CFrogColorManagedSurface* r) {
|
||||
LOGM(TRACE, "Destroy frog cm and xx cm for surface {}", (uintptr_t)surface);
|
||||
if (surface.valid())
|
||||
PROTO::colorManagement->destroyResource(surface->colorManagement.get());
|
||||
PROTO::frogColorManagement->destroyResource(this);
|
||||
});
|
||||
} else
|
||||
resource->setOnDestroy([this](CFrogColorManagedSurface* r) {
|
||||
LOGM(TRACE, "Destroy frog cm surface {}", (uintptr_t)surface);
|
||||
PROTO::frogColorManagement->destroyResource(this);
|
||||
});
|
||||
|
||||
resource->setDestroy([this](CFrogColorManagedSurface* r) {
|
||||
LOGM(TRACE, "Destroy frog cm surface {}", (uintptr_t)surface);
|
||||
PROTO::frogColorManagement->destroyResource(this);
|
||||
});
|
||||
|
||||
resource->setSetKnownTransferFunction([this](CFrogColorManagedSurface* r, frogColorManagedSurfaceTransferFunction tf) {
|
||||
LOGM(TRACE, "Set frog cm transfer function {} for {}", (uint32_t)tf, surface->id());
|
||||
switch (tf) {
|
||||
case FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_ST2084_PQ:
|
||||
surface->colorManagement->m_imageDescription.transferFunction = XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_ST2084_PQ;
|
||||
break;
|
||||
;
|
||||
case FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_GAMMA_22:
|
||||
if (pqIntentSent) {
|
||||
LOGM(TRACE,
|
||||
"FIXME: assuming broken enum value 2 (FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_GAMMA_22) referring to eotf value 2 (TRANSFER_FUNCTION_ST2084_PQ)");
|
||||
surface->colorManagement->m_imageDescription.transferFunction = XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_ST2084_PQ;
|
||||
break;
|
||||
}; // intended fall through
|
||||
case FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_UNDEFINED:
|
||||
case FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_SCRGB_LINEAR: LOGM(TRACE, std::format("FIXME: add tf support for {}", (uint32_t)tf)); // intended fall through
|
||||
case FROG_COLOR_MANAGED_SURFACE_TRANSFER_FUNCTION_SRGB:
|
||||
surface->colorManagement->m_imageDescription.transferFunction = XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_SRGB;
|
||||
|
||||
surface->colorManagement->m_hasImageDescription = true;
|
||||
}
|
||||
});
|
||||
resource->setSetKnownContainerColorVolume([this](CFrogColorManagedSurface* r, frogColorManagedSurfacePrimaries primariesName) {
|
||||
LOGM(TRACE, "Set frog cm primaries {}", (uint32_t)primariesName);
|
||||
switch (primariesName) {
|
||||
case FROG_COLOR_MANAGED_SURFACE_PRIMARIES_UNDEFINED:
|
||||
case FROG_COLOR_MANAGED_SURFACE_PRIMARIES_REC709: surface->colorManagement->m_imageDescription.primaries = NColorPrimaries::BT709; break;
|
||||
case FROG_COLOR_MANAGED_SURFACE_PRIMARIES_REC2020: surface->colorManagement->m_imageDescription.primaries = NColorPrimaries::BT2020; break;
|
||||
}
|
||||
|
||||
surface->colorManagement->m_hasImageDescription = true;
|
||||
});
|
||||
resource->setSetRenderIntent([this](CFrogColorManagedSurface* r, frogColorManagedSurfaceRenderIntent intent) {
|
||||
LOGM(TRACE, "Set frog cm intent {}", (uint32_t)intent);
|
||||
pqIntentSent = intent == FROG_COLOR_MANAGED_SURFACE_RENDER_INTENT_PERCEPTUAL;
|
||||
surface->colorManagement->m_hasImageDescription = true;
|
||||
});
|
||||
resource->setSetHdrMetadata([this](CFrogColorManagedSurface* r, uint32_t r_x, uint32_t r_y, uint32_t g_x, uint32_t g_y, uint32_t b_x, uint32_t b_y, uint32_t w_x, uint32_t w_y,
|
||||
uint32_t max_lum, uint32_t min_lum, uint32_t cll, uint32_t fall) {
|
||||
LOGM(TRACE, "Set frog primaries r:{},{} g:{},{} b:{},{} w:{},{} luminances {} - {} cll {} fall {}", r_x, r_y, g_x, g_y, b_x, b_y, w_x, w_y, min_lum, max_lum, cll, fall);
|
||||
surface->colorManagement->m_imageDescription.masteringPrimaries = SImageDescription::SPCPRimaries{.red = {.x = r_x / 50000.0f, .y = r_y / 50000.0f},
|
||||
.green = {.x = g_x / 50000.0f, .y = g_y / 50000.0f},
|
||||
.blue = {.x = b_x / 50000.0f, .y = b_y / 50000.0f},
|
||||
.white = {.x = w_x / 50000.0f, .y = w_y / 50000.0f}};
|
||||
surface->colorManagement->m_imageDescription.masteringLuminances.min = min_lum / 10000.0f;
|
||||
surface->colorManagement->m_imageDescription.masteringLuminances.max = max_lum;
|
||||
surface->colorManagement->m_imageDescription.maxCLL = cll;
|
||||
surface->colorManagement->m_imageDescription.maxFALL = fall;
|
||||
|
||||
surface->colorManagement->m_hasImageDescription = true;
|
||||
});
|
||||
}
|
||||
|
||||
bool CFrogColorManagementSurface::good() {
|
||||
return resource->resource();
|
||||
}
|
||||
|
||||
wl_client* CFrogColorManagementSurface::client() {
|
||||
return pClient;
|
||||
}
|
||||
|
||||
CFrogColorManagementProtocol::CFrogColorManagementProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
|
||||
;
|
||||
}
|
||||
|
||||
void CFrogColorManagementProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
|
||||
const auto RESOURCE = m_vManagers.emplace_back(makeShared<CFrogColorManager>(makeShared<CFrogColorManagementFactoryV1>(client, ver, id)));
|
||||
|
||||
if (!RESOURCE->good()) {
|
||||
wl_client_post_no_memory(client);
|
||||
m_vManagers.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
LOGM(TRACE, "New frog_color_management at {:x}", (uintptr_t)RESOURCE.get());
|
||||
}
|
||||
|
||||
void CFrogColorManagementProtocol::destroyResource(CFrogColorManager* resource) {
|
||||
std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
|
||||
void CFrogColorManagementProtocol::destroyResource(CFrogColorManagementSurface* resource) {
|
||||
std::erase_if(m_vSurfaces, [&](const auto& other) { return other.get() == resource; });
|
||||
}
|
||||
55
src/protocols/FrogColorManagement.hpp
Normal file
55
src/protocols/FrogColorManagement.hpp
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <cstdint>
|
||||
#include "WaylandProtocol.hpp"
|
||||
#include "protocols/core/Compositor.hpp"
|
||||
#include "frog-color-management-v1.hpp"
|
||||
|
||||
class CFrogColorManager {
|
||||
public:
|
||||
CFrogColorManager(SP<CFrogColorManagementFactoryV1> resource_);
|
||||
|
||||
bool good();
|
||||
|
||||
private:
|
||||
SP<CFrogColorManagementFactoryV1> resource;
|
||||
};
|
||||
|
||||
class CFrogColorManagementSurface {
|
||||
public:
|
||||
CFrogColorManagementSurface(SP<CFrogColorManagedSurface> resource_, SP<CWLSurfaceResource> surface_);
|
||||
|
||||
bool good();
|
||||
wl_client* client();
|
||||
|
||||
WP<CFrogColorManagementSurface> self;
|
||||
WP<CWLSurfaceResource> surface;
|
||||
|
||||
bool pqIntentSent = false;
|
||||
|
||||
private:
|
||||
SP<CFrogColorManagedSurface> resource;
|
||||
wl_client* pClient = nullptr;
|
||||
};
|
||||
|
||||
class CFrogColorManagementProtocol : public IWaylandProtocol {
|
||||
public:
|
||||
CFrogColorManagementProtocol(const wl_interface* iface, const int& ver, const std::string& name);
|
||||
|
||||
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
|
||||
|
||||
private:
|
||||
void destroyResource(CFrogColorManager* resource);
|
||||
void destroyResource(CFrogColorManagementSurface* resource);
|
||||
|
||||
std::vector<SP<CFrogColorManager>> m_vManagers;
|
||||
std::vector<SP<CFrogColorManagementSurface>> m_vSurfaces;
|
||||
|
||||
friend class CFrogColorManager;
|
||||
friend class CFrogColorManagementSurface;
|
||||
};
|
||||
|
||||
namespace PROTO {
|
||||
inline UP<CFrogColorManagementProtocol> frogColorManagement;
|
||||
};
|
||||
|
|
@ -25,6 +25,8 @@ class CWLSurfaceResource;
|
|||
class CWLSubsurfaceResource;
|
||||
class CViewportResource;
|
||||
class CDRMSyncobjSurfaceResource;
|
||||
class CColorManagementSurface;
|
||||
class CFrogColorManagementSurface;
|
||||
|
||||
class CWLCallbackResource {
|
||||
public:
|
||||
|
|
@ -121,6 +123,7 @@ class CWLSurfaceResource {
|
|||
SP<ISurfaceRole> role;
|
||||
WP<CViewportResource> viewportResource;
|
||||
WP<CDRMSyncobjSurfaceResource> syncobj; // may not be present
|
||||
WP<CColorManagementSurface> colorManagement;
|
||||
|
||||
void breadthfirst(std::function<void(SP<CWLSurfaceResource>, const Vector2D&, void*)> fn, void* data);
|
||||
CRegion accumulateCurrentBufferDamage();
|
||||
|
|
|
|||
47
src/protocols/types/ColorManagement.hpp
Normal file
47
src/protocols/types/ColorManagement.hpp
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
#pragma once
|
||||
|
||||
#include "xx-color-management-v4.hpp"
|
||||
|
||||
struct SImageDescription {
|
||||
int iccFd = -1;
|
||||
uint32_t iccSize = 0;
|
||||
|
||||
xxColorManagerV4TransferFunction transferFunction = XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_SRGB;
|
||||
float transferFunctionPower = 1.0f;
|
||||
|
||||
bool primariesNameSet = false;
|
||||
xxColorManagerV4Primaries primariesNamed = XX_COLOR_MANAGER_V4_PRIMARIES_SRGB;
|
||||
// primaries are stored as FP values with the same scale as standard defines (0.0 - 1.0)
|
||||
// wayland protocol expects int32_t values multiplied by 10000
|
||||
// drm expects uint16_t values multiplied by 50000
|
||||
// frog protocol expects drm values
|
||||
struct SPCPRimaries {
|
||||
struct {
|
||||
float x = 0;
|
||||
float y = 0;
|
||||
} red, green, blue, white;
|
||||
} primaries, masteringPrimaries;
|
||||
|
||||
// luminances in cd/m²
|
||||
// protos and drm expect min * 10000
|
||||
struct SPCLuminances {
|
||||
float min = 0.2; // 0.2 cd/m²
|
||||
uint32_t max = 80; // 80 cd/m²
|
||||
uint32_t reference = 80; // 80 cd/m²
|
||||
} luminances;
|
||||
struct SPCMasteringLuminances {
|
||||
float min = 0;
|
||||
uint32_t max = 0;
|
||||
} masteringLuminances;
|
||||
|
||||
uint32_t maxCLL = 0;
|
||||
uint32_t maxFALL = 0;
|
||||
};
|
||||
|
||||
namespace NColorPrimaries {
|
||||
static const auto BT709 =
|
||||
SImageDescription::SPCPRimaries{.red = {.x = 0.64, .y = 0.33}, .green = {.x = 0.30, .y = 0.60}, .blue = {.x = 0.15, .y = 0.06}, .white = {.x = 0.3127, .y = 0.3290}};
|
||||
|
||||
static const auto BT2020 =
|
||||
SImageDescription::SPCPRimaries{.red = {.x = 0.708, .y = 0.292}, .green = {.x = 0.170, .y = 0.797}, .blue = {.x = 0.131, .y = 0.046}, .white = {.x = 0.3127, .y = 0.3290}};
|
||||
}
|
||||
|
|
@ -25,6 +25,7 @@
|
|||
#include "pass/RendererHintsPassElement.hpp"
|
||||
#include "pass/SurfacePassElement.hpp"
|
||||
#include "debug/Log.hpp"
|
||||
#include "protocols/ColorManagement.hpp"
|
||||
|
||||
#include <hyprutils/utils/ScopeGuard.hpp>
|
||||
using namespace Hyprutils::Utils;
|
||||
|
|
@ -1374,6 +1375,82 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
|
|||
}
|
||||
}
|
||||
|
||||
static const auto BT709 = Aquamarine::IOutput::SChromaticityCoords{
|
||||
.red = Aquamarine::IOutput::xy{.x = 0.64, .y = 0.33},
|
||||
.green = Aquamarine::IOutput::xy{.x = 0.30, .y = 0.60},
|
||||
.blue = Aquamarine::IOutput::xy{.x = 0.15, .y = 0.06},
|
||||
.white = Aquamarine::IOutput::xy{.x = 0.3127, .y = 0.3290},
|
||||
};
|
||||
|
||||
static hdr_output_metadata createHDRMetadata(uint8_t eotf, Aquamarine::IOutput::SParsedEDID edid) {
|
||||
if (eotf == 0)
|
||||
return hdr_output_metadata{.hdmi_metadata_type1 = hdr_metadata_infoframe{.eotf = 0}}; // empty metadata for SDR
|
||||
|
||||
const auto toNits = [](float value) { return uint16_t(std::round(value)); };
|
||||
const auto to16Bit = [](float value) { return uint16_t(std::round(value * 50000)); };
|
||||
const auto colorimetry = edid.chromaticityCoords.value_or(BT709);
|
||||
|
||||
Debug::log(TRACE, "ColorManagement primaries {},{} {},{} {},{} {},{}", colorimetry.red.x, colorimetry.red.y, colorimetry.green.x, colorimetry.green.y, colorimetry.blue.x,
|
||||
colorimetry.blue.y, colorimetry.white.x, colorimetry.white.y);
|
||||
Debug::log(TRACE, "ColorManagement max avg {}, min {}, max {}", edid.hdrMetadata->desiredMaxFrameAverageLuminance, edid.hdrMetadata->desiredContentMinLuminance,
|
||||
edid.hdrMetadata->desiredContentMaxLuminance);
|
||||
return hdr_output_metadata{
|
||||
.metadata_type = 0,
|
||||
.hdmi_metadata_type1 =
|
||||
hdr_metadata_infoframe{
|
||||
.eotf = eotf,
|
||||
.metadata_type = 0,
|
||||
.display_primaries =
|
||||
{
|
||||
{.x = to16Bit(colorimetry.red.x), .y = to16Bit(colorimetry.red.y)},
|
||||
{.x = to16Bit(colorimetry.green.x), .y = to16Bit(colorimetry.green.y)},
|
||||
{.x = to16Bit(colorimetry.blue.x), .y = to16Bit(colorimetry.blue.y)},
|
||||
},
|
||||
.white_point = {.x = to16Bit(colorimetry.white.x), .y = to16Bit(colorimetry.white.y)},
|
||||
.max_display_mastering_luminance = toNits(edid.hdrMetadata->desiredMaxFrameAverageLuminance),
|
||||
.min_display_mastering_luminance = toNits(edid.hdrMetadata->desiredContentMinLuminance * 10000),
|
||||
.max_cll = toNits(edid.hdrMetadata->desiredMaxFrameAverageLuminance),
|
||||
.max_fall = toNits(edid.hdrMetadata->desiredMaxFrameAverageLuminance),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
static hdr_output_metadata createHDRMetadata(SImageDescription settings, Aquamarine::IOutput::SParsedEDID edid) {
|
||||
if (settings.transferFunction != XX_COLOR_MANAGER_V4_TRANSFER_FUNCTION_ST2084_PQ)
|
||||
return hdr_output_metadata{.hdmi_metadata_type1 = hdr_metadata_infoframe{.eotf = 0}}; // empty metadata for SDR
|
||||
|
||||
const auto toNits = [](uint32_t value) { return uint16_t(std::round(value)); };
|
||||
const auto to16Bit = [](uint32_t value) { return uint16_t(std::round(value * 50000)); };
|
||||
|
||||
auto colorimetry = settings.primaries;
|
||||
auto luminances = settings.masteringLuminances.max > 0 ?
|
||||
settings.masteringLuminances :
|
||||
SImageDescription::SPCMasteringLuminances{.min = edid.hdrMetadata->desiredContentMinLuminance, .max = edid.hdrMetadata->desiredContentMaxLuminance};
|
||||
|
||||
Debug::log(TRACE, "ColorManagement primaries {},{} {},{} {},{} {},{}", colorimetry.red.x, colorimetry.red.y, colorimetry.green.x, colorimetry.green.y, colorimetry.blue.x,
|
||||
colorimetry.blue.y, colorimetry.white.x, colorimetry.white.y);
|
||||
Debug::log(TRACE, "ColorManagement min {}, max {}, cll {}, fall {}", luminances.min, luminances.max, settings.maxCLL, settings.maxFALL);
|
||||
return hdr_output_metadata{
|
||||
.metadata_type = 0,
|
||||
.hdmi_metadata_type1 =
|
||||
hdr_metadata_infoframe{
|
||||
.eotf = 2,
|
||||
.metadata_type = 0,
|
||||
.display_primaries =
|
||||
{
|
||||
{.x = to16Bit(colorimetry.red.x), .y = to16Bit(colorimetry.red.y)},
|
||||
{.x = to16Bit(colorimetry.green.x), .y = to16Bit(colorimetry.green.y)},
|
||||
{.x = to16Bit(colorimetry.blue.x), .y = to16Bit(colorimetry.blue.y)},
|
||||
},
|
||||
.white_point = {.x = to16Bit(colorimetry.white.x), .y = to16Bit(colorimetry.white.y)},
|
||||
.max_display_mastering_luminance = toNits(luminances.max),
|
||||
.min_display_mastering_luminance = toNits(luminances.min * 10000),
|
||||
.max_cll = toNits(settings.maxCLL),
|
||||
.max_fall = toNits(settings.maxFALL),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
|
||||
// apply timelines for explicit sync
|
||||
// save inFD otherwise reset will reset it
|
||||
|
|
@ -1382,6 +1459,26 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
|
|||
if (inFD >= 0)
|
||||
pMonitor->output->state->setExplicitInFence(inFD);
|
||||
|
||||
static auto PWIDE = CConfigValue<Hyprlang::INT>("experimental:wide_color_gamut");
|
||||
if (pMonitor->output->state->state().wideColorGamut != *PWIDE)
|
||||
Debug::log(TRACE, "Setting wide color gamut {}", *PWIDE ? "on" : "off");
|
||||
pMonitor->output->state->setWideColorGamut(*PWIDE);
|
||||
|
||||
static auto PHDR = CConfigValue<Hyprlang::INT>("experimental:hdr");
|
||||
|
||||
Debug::log(TRACE, "ColorManagement supportsBT2020 {}, supportsPQ {}", pMonitor->output->parsedEDID.supportsBT2020, pMonitor->output->parsedEDID.hdrMetadata->supportsPQ);
|
||||
if (pMonitor->output->parsedEDID.supportsBT2020 && pMonitor->output->parsedEDID.hdrMetadata->supportsPQ) {
|
||||
if (pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_bHasFullscreenWindow && pMonitor->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) {
|
||||
const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow();
|
||||
const auto SURF = WINDOW->m_pWLSurface->resource();
|
||||
if (SURF->colorManagement.valid() && SURF->colorManagement->hasImageDescription())
|
||||
pMonitor->output->state->setHDRMetadata(createHDRMetadata(SURF->colorManagement.get()->imageDescription(), pMonitor->output->parsedEDID));
|
||||
else
|
||||
pMonitor->output->state->setHDRMetadata(*PHDR ? createHDRMetadata(2, pMonitor->output->parsedEDID) : createHDRMetadata(0, pMonitor->output->parsedEDID));
|
||||
} else
|
||||
pMonitor->output->state->setHDRMetadata(*PHDR ? createHDRMetadata(2, pMonitor->output->parsedEDID) : createHDRMetadata(0, pMonitor->output->parsedEDID));
|
||||
}
|
||||
|
||||
if (pMonitor->ctmUpdated) {
|
||||
pMonitor->ctmUpdated = false;
|
||||
pMonitor->output->state->setCTM(pMonitor->ctm);
|
||||
|
|
|
|||
|
|
@ -79,6 +79,8 @@ void CSurfacePassElement::draw(const CRegion& damage) {
|
|||
DELTALESSTHAN(windowBox.height, data.surface->current.bufferSize.y, 3) /* off by one-or-two */ &&
|
||||
(!data.pWindow || (!data.pWindow->m_vRealSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */;
|
||||
|
||||
if (data.surface->colorManagement.valid())
|
||||
Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations");
|
||||
g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
|
||||
|
||||
// check for fractional scale surfaces misaligning the buffer size
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue