add lut ramps

Author: vaxerski

src/helpers/cm/ColorManagement.hpp

@@ -16,6 +16,8 @@
 #define HDR_REF_LUMINANCE 203.0
 #define HLG_MAX_LUMINANCE 1000.0
 
+class CTexture;
+
 namespace NColorManagement {
     enum eNoShader : uint8_t {
         CM_NS_DISABLE  = 0,
@@ -175,6 +177,13 @@ namespace NColorManagement {
             }
         } masteringLuminances;
 
+        // LUT ramps replace destTF. These are used for ICC.
+        // These are INVERTED, ready for linear -> dest
+        struct SLUTRamps {
+            bool         present = false;
+            SP<CTexture> r, g, b;
+        } lutRamps;
+
         uint32_t maxCLL  = 0;
         uint32_t maxFALL = 0;
 

src/helpers/cm/ICC.cpp

@@ -4,6 +4,8 @@
 #include <fstream>
 
 #include "../../debug/log/Logger.hpp"
+#include "../../render/Texture.hpp"
+#include "../../render/Renderer.hpp"
 
 #include <hyprutils/utils/ScopeGuard.hpp>
 using namespace Hyprutils::Utils;
@@ -12,6 +14,9 @@ using namespace Hyprutils::Utils;
 
 using namespace NColorManagement;
 
+// IMPORTANT: this needs to match LUT_SIZE in CM.glsl
+constexpr const size_t      LUT_SIZE = 2048;
+
 static std::vector<uint8_t> readBinary(const std::filesystem::path& file) {
     std::ifstream ifs(file, std::ios::binary);
     if (!ifs.good())
@@ -118,21 +123,6 @@ static std::optional<Mat3x3> invertMat3(const Mat3x3& m) {
     return inv;
 }
 
-static bool toneCurvesSimilar(cmsToneCurve* a, cmsToneCurve* b) {
-    if (!a || !b)
-        return false;
-
-    for (int i = 0; i <= 256; ++i) {
-        double x  = (double)i / 256.0;
-        double ya = cmsEvalToneCurveFloat(a, x);
-        double yb = cmsEvalToneCurveFloat(b, x);
-        if (std::abs(ya - yb) > 0.001) // close enough
-            return false;
-    }
-
-    return true;
-}
-
 static std::string dumpToneCurve(cmsToneCurve* c) {
     if (!c)
         return "";
@@ -152,6 +142,25 @@ static std::string dumpToneCurve(cmsToneCurve* c) {
     return res;
 }
 
+static SP<CTexture> uploadRamp(std::span<const float> data) {
+    g_pHyprRenderer->makeEGLCurrent();
+
+    SP<CTexture> tex = makeShared<CTexture>(data);
+
+    return tex;
+}
+
+static std::vector<float> sampleToneCurve(cmsToneCurve* curve) {
+    std::vector<float> lut;
+    lut.reserve(LUT_SIZE);
+    for (size_t i = 0; i < LUT_SIZE; ++i) {
+        float x = sc<float>(i) / sc<float>(LUT_SIZE - 1);
+        float y = sc<float>(cmsEvalToneCurveFloat(curve, x));
+        lut.emplace_back(std::clamp(y, 0.F, 1.F));
+    }
+    return lut;
+}
+
 std::expected<SImageDescription, std::string> SImageDescription::fromICC(const std::filesystem::path& file) {
     std::error_code ec;
     if (!std::filesystem::exists(file, ec) || ec)
@@ -228,37 +237,30 @@ std::expected<SImageDescription, std::string> SImageDescription::fromICC(const s
     Log::logger->log(Log::DEBUG, "TRC G: {}", dumpToneCurve(trcG));
     Log::logger->log(Log::DEBUG, "TRC B: {}", dumpToneCurve(trcB));
 
-    // FIXME: make this representable...
-    cmsToneCurve* trc = trcR;
-    if (trcR && trcG && trcB && (!toneCurvesSimilar(trcR, trcG) || !toneCurvesSimilar(trcR, trcB))) {
-        Log::logger->log(Log::DEBUG, "============= End ICC load =============");
-        return std::unexpected("Hyprland cannot represent split-trc profiles yet");
-    }
+    if (trcR && trcG && trcB) {
+        Log::logger->log(Log::DEBUG, "All TRC present, uploading LUTs", dumpToneCurve(trcR));
 
-    if (trc) {
-        if (cmsIsToneCurveLinear(trc)) {
-            Log::logger->log(Log::DEBUG, "TRC: Linear");
-            image.transferFunction      = CM_TRANSFER_FUNCTION_EXT_LINEAR;
-            image.transferFunctionPower = 1.F;
-        } else {
-            // gamma fit as a fallback
-            Log::logger->log(Log::DEBUG, "TRC: Gamma fit");
-            const double g = cmsEstimateGamma(trc, 0.000001);
-            if (g > 1.0 && g < 4.0) {
-                Log::logger->log(Log::DEBUG, "TRC: Gamma fit at {}", g);
-                image.transferFunctionPower = (float)g;
-
-                if (std::abs(g - 2.2) < 0.05)
-                    image.transferFunction = CM_TRANSFER_FUNCTION_GAMMA22;
-                else if (std::abs(g - 2.8) < 0.05)
-                    image.transferFunction = CM_TRANSFER_FUNCTION_GAMMA28;
-                else
-                    image.transferFunction = CM_TRANSFER_FUNCTION_EXT_SRGB;
-            } else {
-                Log::logger->log(Log::DEBUG, "TRC: Gamma fit failed, falling back to srgb");
-                image.transferFunction = CM_TRANSFER_FUNCTION_SRGB;
-            }
-        }
+        image.lutRamps.present = true;
+
+        cmsToneCurve* invR = cmsReverseToneCurve(trcR);
+        cmsToneCurve* invG = cmsReverseToneCurve(trcG);
+        cmsToneCurve* invB = cmsReverseToneCurve(trcB);
+
+        CScopeGuard   x2([&] {
+            if (invR)
+                cmsFreeToneCurve(invR);
+            if (invG)
+                cmsFreeToneCurve(invG);
+            if (invB)
+                cmsFreeToneCurve(invB);
+        });
+
+        if (!invR || !invG || !invB)
+            return std::unexpected("Failed to invert TRC, likely invalid/unsupported data");
+
+        image.lutRamps.r = uploadRamp(sampleToneCurve(invR));
+        image.lutRamps.g = uploadRamp(sampleToneCurve(invG));
+        image.lutRamps.b = uploadRamp(sampleToneCurve(invB));
     }
 
     Log::logger->log(Log::DEBUG, "============= End ICC load =============");

src/render/OpenGL.cpp

@@ -967,6 +967,10 @@ static void getCMShaderUniforms(SShader& shader) {
     shader.uniformLocations[SHADER_SDR_SATURATION]    = glGetUniformLocation(shader.program, "sdrSaturation");
     shader.uniformLocations[SHADER_SDR_BRIGHTNESS]    = glGetUniformLocation(shader.program, "sdrBrightnessMultiplier");
     shader.uniformLocations[SHADER_CONVERT_MATRIX]    = glGetUniformLocation(shader.program, "convertMatrix");
+    shader.uniformLocations[SHADER_USE_LUT]           = glGetUniformLocation(shader.program, "useLUTRamps");
+    shader.uniformLocations[SHADER_LUT_R]             = glGetUniformLocation(shader.program, "dstLUTR");
+    shader.uniformLocations[SHADER_LUT_G]             = glGetUniformLocation(shader.program, "dstLUTG");
+    shader.uniformLocations[SHADER_LUT_B]             = glGetUniformLocation(shader.program, "dstLUTB");
 }
 
 // shader has #include "rounding.glsl"
@@ -1614,6 +1618,26 @@ void CHyprOpenGLImpl::passCMUniforms(SShader& shader, const NColorManagement::SI
         primariesConversionCache.insert(std::make_pair(cacheKey, glConvertMatrix));
     }
     shader.setUniformMatrix3fv(SHADER_CONVERT_MATRIX, 1, false, primariesConversionCache[cacheKey]);
+
+    if (targetImageDescription.lutRamps.present) {
+        // this will override any dstTF set
+        shader.setUniformInt(SHADER_USE_LUT, 1);
+
+        // TODO: make this less hacky or sumn
+        glActiveTexture(GL_TEXTURE5);
+        targetImageDescription.lutRamps.r->bind();
+
+        glActiveTexture(GL_TEXTURE6);
+        targetImageDescription.lutRamps.g->bind();
+
+        glActiveTexture(GL_TEXTURE7);
+        targetImageDescription.lutRamps.b->bind();
+
+        shader.setUniformInt(SHADER_LUT_R, 5);
+        shader.setUniformInt(SHADER_LUT_G, 6);
+        shader.setUniformInt(SHADER_LUT_B, 7);
+    } else
+        shader.setUniformInt(SHADER_USE_LUT, 0);
 }
 
 void CHyprOpenGLImpl::passCMUniforms(SShader& shader, const SImageDescription& imageDescription) {

src/render/Shader.hpp

@@ -76,6 +76,10 @@ enum eShaderUniform : uint8_t {
     SHADER_POINTER_INACTIVE_TIMEOUT,
     SHADER_POINTER_LAST_ACTIVE,
     SHADER_POINTER_SIZE,
+    SHADER_USE_LUT,
+    SHADER_LUT_R,
+    SHADER_LUT_G,
+    SHADER_LUT_B,
 
     SHADER_LAST,
 };

src/render/Texture.cpp

@@ -58,6 +58,18 @@ CTexture::CTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy) : m_
     createFromDma(attrs, image);
 }
 
+CTexture::CTexture(std::span<const float> data1D) : m_type(TEXTURE_R), m_size(data1D.size(), 1), m_isSynchronous(true) {
+    allocate();
+    bind();
+    setTexParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    setTexParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    GLCALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, data1D.size(), 1, 0, GL_RED, GL_FLOAT, data1D.data()));
+    unbind();
+}
+
 void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size_) {
     g_pHyprRenderer->makeEGLCurrent();
 

src/render/Texture.hpp

@@ -3,6 +3,7 @@
 #include "../defines.hpp"
 #include <aquamarine/buffer/Buffer.hpp>
 #include <hyprutils/math/Misc.hpp>
+#include <span>
 
 class IHLBuffer;
 HYPRUTILS_FORWARD(Math, CRegion);
@@ -11,6 +12,7 @@ enum eTextureType : int8_t {
     TEXTURE_INVALID = -1, // Invalid
     TEXTURE_RGBA    = 0,  // 4 channels
     TEXTURE_RGBX,         // discard A
+    TEXTURE_R,            // only 1 channel
     TEXTURE_EXTERNAL,     // EGLImage
 };
 
@@ -24,6 +26,7 @@ class CTexture {
     CTexture(const CTexture&)  = delete;
 
     CTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size, bool keepDataCopy = false);
+    CTexture(std::span<const float> data1D);
 
     CTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy = false);
     // this ctor takes ownership of the eglImage.

src/render/shaders/glsl/CM.glsl

@@ -9,6 +9,14 @@ uniform float sdrSaturation;
 uniform float sdrBrightnessMultiplier;
 uniform mat3 convertMatrix;
 
+uniform int useLUTRamps;
+uniform sampler2D dstLUTR;
+uniform sampler2D dstLUTG;
+uniform sampler2D dstLUTB;
+
+// IMPORTANT: this needs to match LUT_SIZE in ICC.cpp
+#define LUT_SIZE 2048.0
+
 //enum eTransferFunction
 #define CM_TRANSFER_FUNCTION_BT1886     1
 #define CM_TRANSFER_FUNCTION_GAMMA22    2
@@ -68,6 +76,19 @@ uniform mat3 convertMatrix;
 
 #define M_E 2.718281828459045
 
+float sampleLUT(sampler2D t, float x) {
+    float u = (clamp(x, 0.0, 1.0) * (LUT_SIZE - 1.0) + 0.5) / LUT_SIZE;
+    return texture(t, vec2(u, 0.5)).r;
+}
+
+vec3 linearToOutputWithLUT(vec3 lin) {
+    return vec3(
+        sampleLUT(dstLUTR, lin.r),
+        sampleLUT(dstLUTG, lin.g),
+        sampleLUT(dstLUTB, lin.b)
+    );
+}
+
 vec3 xy2xyz(vec2 xy) {
     if (xy.y == 0.0)
         return vec3(0.0, 0.0, 0.0);
@@ -268,13 +289,16 @@ vec4 fromLinear(vec4 color, int tf) {
     return color;
 }
 
-vec4 fromLinearNit(vec4 color, int tf, vec2 range) {
-    if (tf == CM_TRANSFER_FUNCTION_EXT_LINEAR)
+vec4 fromLinearNit(vec4 color, int tf, vec2 range) {    
+    if (tf == CM_TRANSFER_FUNCTION_EXT_LINEAR && useLUTRamps != 1)
         color.rgb = color.rgb / SDR_MAX_LUMINANCE;
     else {
         color.rgb /= max(color.a, 0.001);
         color.rgb = (color.rgb - range[0]) / (range[1] - range[0]);
-        color.rgb = fromLinearRGB(color.rgb, tf);
+        if (useLUTRamps == 1)
+            color.rgb = linearToOutputWithLUT(color.rgb);
+        else
+            color.rgb = fromLinearRGB(color.rgb, tf);
         color.rgb *= color.a;
     }
     return color;