csputils: replace more primitives with pl_

We can go deeper, but need to stop somewhere to not reimplement vo_gpu
using libplacebo...

3 files changed, 33 insertions, 32 deletions

diff --git a/video/out/gpu/lcms.c b/video/out/gpu/lcms.c
index 00d819d2f0..1e451aa7a2 100644
--- a/video/out/gpu/lcms.c
+++ b/video/out/gpu/lcms.c
@@ -197,12 +197,12 @@ static cmsHPROFILE get_vid_profile(struct gl_lcms *p, cmsContext cms,
 
     // The input profile for the transformation is dependent on the video
     // primaries and transfer characteristics
-    struct mp_csp_primaries csp = mp_get_csp_primaries(prim);
-    cmsCIExyY wp_xyY = {csp.white.x, csp.white.y, 1.0};
+    const struct pl_raw_primaries *csp = pl_raw_primaries_get(prim);
+    cmsCIExyY wp_xyY = {csp->white.x, csp->white.y, 1.0};
     cmsCIExyYTRIPLE prim_xyY = {
-        .Red   = {csp.red.x,   csp.red.y,   1.0},
-        .Green = {csp.green.x, csp.green.y, 1.0},
-        .Blue  = {csp.blue.x,  csp.blue.y,  1.0},
+        .Red   = {csp->red.x,   csp->red.y,   1.0},
+        .Green = {csp->green.x, csp->green.y, 1.0},
+        .Blue  = {csp->blue.x,  csp->blue.y,  1.0},
     };
 
     cmsToneCurve *tonecurve[3] = {0};
@@ -242,7 +242,7 @@ static cmsHPROFILE get_vid_profile(struct gl_lcms *p, cmsContext cms,
             // function. Relative colorimetric is used since we want to
             // approximate the BT.1886 to the target device's actual black
             // point even in e.g. perceptual mode
-            const int intent = MP_INTENT_RELATIVE_COLORIMETRIC;
+            const int intent = PL_INTENT_RELATIVE_COLORIMETRIC;
             cmsCIEXYZ bp_XYZ;
             if (!cmsDetectBlackPoint(&bp_XYZ, disp_profile, intent, 0))
                 return false;
@@ -519,7 +519,7 @@ const struct m_sub_options mp_icc_conf = {
     .size = sizeof(struct mp_icc_opts),
     .defaults = &(const struct mp_icc_opts) {
         .size_str = "auto",
-        .intent = MP_INTENT_RELATIVE_COLORIMETRIC,
+        .intent = PL_INTENT_RELATIVE_COLORIMETRIC,
         .use_embedded = true,
         .cache = true,
     },
diff --git a/video/out/gpu/video.c b/video/out/gpu/video.c
index 5e0175366a..fcde3cd5c9 100644
--- a/video/out/gpu/video.c
+++ b/video/out/gpu/video.c
@@ -2344,9 +2344,9 @@ static void pass_convert_yuv(struct gl_video *p)
 
     // Conversion to RGB. For RGB itself, this still applies e.g. brightness
     // and contrast controls, or expansion of e.g. LSB-packed 10 bit data.
-    struct mp_cmat m = {{{0}}};
+    struct pl_transform3x3 m = {0};
     mp_get_csp_matrix(&cparams, &m);
-    gl_sc_uniform_mat3(sc, "colormatrix", true, &m.m[0][0]);
+    gl_sc_uniform_mat3(sc, "colormatrix", true, &m.mat.m[0][0]);
     gl_sc_uniform_vec3(sc, "colormatrix_c", m.c);
 
     GLSL(color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;)
@@ -2482,7 +2482,7 @@ static void pass_scale_main(struct gl_video *p)
         // Linear light downscaling results in nasty artifacts for HDR curves
         // due to the potentially extreme brightness differences severely
         // compounding any ringing. So just scale in gamma light instead.
-        if (mp_trc_is_hdr(p->image_params.color.transfer))
+        if (pl_color_space_is_hdr(&p->image_params.color))
             use_linear = false;
     } else if (upscaling) {
         use_linear = p->opts.linear_upscaling || p->opts.sigmoid_upscaling;
@@ -2592,7 +2592,7 @@ static void pass_colormanage(struct gl_video *p, struct pl_color_space src,
         // limitation reasons, so we use a gamma 2.2 input curve here instead.
         // We could pick any value we want here, the difference is just coding
         // efficiency.
-        if (mp_trc_is_hdr(trc_orig))
+        if (pl_color_space_is_hdr(&p->image_params.color))
             trc_orig = PL_COLOR_TRC_GAMMA22;
 
         if (gl_video_get_lut3d(p, prim_orig, trc_orig)) {
@@ -2629,7 +2629,7 @@ static void pass_colormanage(struct gl_video *p, struct pl_color_space src,
         // Avoid outputting linear light or HDR content "by default". For these
         // just pick gamma 2.2 as a default, since it's a good estimate for
         // the response of typical displays
-        if (dst.transfer == PL_COLOR_TRC_LINEAR || mp_trc_is_hdr(dst.transfer))
+        if (dst.transfer == PL_COLOR_TRC_LINEAR || pl_color_space_is_hdr(&dst))
             dst.transfer = PL_COLOR_TRC_GAMMA22;
     }
 
@@ -2637,9 +2637,9 @@ static void pass_colormanage(struct gl_video *p, struct pl_color_space src,
     // it from the chosen transfer function. Also normalize the src peak, in
     // case it was unknown
     if (!dst.hdr.max_luma)
-        dst.hdr.max_luma = mp_trc_nom_peak(dst.transfer) * MP_REF_WHITE;
+        dst.hdr.max_luma = pl_color_transfer_nominal_peak(dst.transfer) * MP_REF_WHITE;
     if (!src.hdr.max_luma)
-        src.hdr.max_luma = mp_trc_nom_peak(src.transfer) * MP_REF_WHITE;
+        src.hdr.max_luma = pl_color_transfer_nominal_peak(src.transfer) * MP_REF_WHITE;
 
     // Whitelist supported modes
     switch (p->opts.tone_map.curve) {
@@ -2671,7 +2671,7 @@ static void pass_colormanage(struct gl_video *p, struct pl_color_space src,
     }
 
     struct gl_tone_map_opts tone_map = p->opts.tone_map;
-    bool detect_peak = tone_map.compute_peak >= 0 && mp_trc_is_hdr(src.transfer)
+    bool detect_peak = tone_map.compute_peak >= 0 && pl_color_space_is_hdr(&src)
                        && src.hdr.max_luma > dst.hdr.max_luma;
 
     if (detect_peak && !p->hdr_peak_ssbo) {
diff --git a/video/out/gpu/video_shaders.c b/video/out/gpu/video_shaders.c
index 2201e12d46..62fe11caae 100644
--- a/video/out/gpu/video_shaders.c
+++ b/video/out/gpu/video_shaders.c
@@ -17,6 +17,8 @@
 
 #include <math.h>
 
+#include <libplacebo/colorspace.h>
+
 #include "video_shaders.h"
 #include "video.h"
 
@@ -337,7 +339,7 @@ static const float SLOG_A = 0.432699,
 //
 // These functions always output to a normalized scale of [0,1], for
 // convenience of the video.c code that calls it. To get the values in an
-// absolute scale, multiply the result by `mp_trc_nom_peak(trc)`
+// absolute scale, multiply the result by `pl_color_transfer_nominal_peak(trc)`
 void pass_linearize(struct gl_shader_cache *sc, enum pl_color_transfer trc)
 {
     if (trc == PL_COLOR_TRC_LINEAR)
@@ -430,7 +432,7 @@ void pass_linearize(struct gl_shader_cache *sc, enum pl_color_transfer trc)
     }
 
     // Rescale to prevent clipping on non-float textures
-    GLSLF("color.rgb *= vec3(1.0/%f);\n", mp_trc_nom_peak(trc));
+    GLSLF("color.rgb *= vec3(1.0/%f);\n", pl_color_transfer_nominal_peak(trc));
 }
 
 // Delinearize (compress), given a TRC as output. This corresponds to the
@@ -445,7 +447,7 @@ void pass_delinearize(struct gl_shader_cache *sc, enum pl_color_transfer trc)
 
     GLSLF("// delinearize\n");
     GLSL(color.rgb = clamp(color.rgb, 0.0, 1.0);)
-    GLSLF("color.rgb *= vec3(%f);\n", mp_trc_nom_peak(trc));
+    GLSLF("color.rgb *= vec3(%f);\n", pl_color_transfer_nominal_peak(trc));
 
     switch (trc) {
     case PL_COLOR_TRC_SRGB:
@@ -842,11 +844,10 @@ void pass_color_map(struct gl_shader_cache *sc, bool is_linear,
 
     // Some operations need access to the video's luma coefficients, so make
     // them available
-    float rgb2xyz[3][3];
-    mp_get_rgb2xyz_matrix(mp_get_csp_primaries(src.primaries), rgb2xyz);
-    gl_sc_uniform_vec3(sc, "src_luma", rgb2xyz[1]);
-    mp_get_rgb2xyz_matrix(mp_get_csp_primaries(dst.primaries), rgb2xyz);
-    gl_sc_uniform_vec3(sc, "dst_luma", rgb2xyz[1]);
+    pl_matrix3x3 rgb2xyz = pl_get_rgb2xyz_matrix(pl_raw_primaries_get(src.primaries));
+    gl_sc_uniform_vec3(sc, "src_luma", rgb2xyz.m[1]);
+    rgb2xyz = pl_get_rgb2xyz_matrix(pl_raw_primaries_get(dst.primaries));
+    gl_sc_uniform_vec3(sc, "dst_luma", rgb2xyz.m[1]);
 
     bool need_ootf = src_light != dst_light;
     if (src_light == MP_CSP_LIGHT_SCENE_HLG && src.hdr.max_luma != dst.hdr.max_luma)
@@ -867,7 +868,7 @@ void pass_color_map(struct gl_shader_cache *sc, bool is_linear,
     }
 
     // Pre-scale the incoming values into an absolute scale
-    GLSLF("color.rgb *= vec3(%f);\n", mp_trc_nom_peak(src.transfer));
+    GLSLF("color.rgb *= vec3(%f);\n", pl_color_transfer_nominal_peak(src.transfer));
 
     if (need_ootf)
         pass_ootf(sc, src_light, src.hdr.max_luma / MP_REF_WHITE);
@@ -880,11 +881,11 @@ void pass_color_map(struct gl_shader_cache *sc, bool is_linear,
 
     // Adapt to the right colorspace if necessary
     if (src.primaries != dst.primaries) {
-        struct mp_csp_primaries csp_src = mp_get_csp_primaries(src.primaries),
-                                csp_dst = mp_get_csp_primaries(dst.primaries);
-        float m[3][3] = {{0}};
-        mp_get_cms_matrix(csp_src, csp_dst, MP_INTENT_RELATIVE_COLORIMETRIC, m);
-        gl_sc_uniform_mat3(sc, "cms_matrix", true, &m[0][0]);
+        const struct pl_raw_primaries *csp_src = pl_raw_primaries_get(src.primaries),
+                                      *csp_dst = pl_raw_primaries_get(dst.primaries);
+        pl_matrix3x3 m = pl_get_color_mapping_matrix(csp_src, csp_dst,
+                                                     PL_INTENT_RELATIVE_COLORIMETRIC);
+        gl_sc_uniform_mat3(sc, "cms_matrix", true, &m.m[0][0]);
         GLSL(color.rgb = cms_matrix * color.rgb;)
 
         if (!opts->gamut_mode || opts->gamut_mode == GAMUT_DESATURATE) {
@@ -907,8 +908,8 @@ void pass_color_map(struct gl_shader_cache *sc, bool is_linear,
     // For SDR, we normalize to the chosen signal peak. For HDR, we normalize
     // to the encoding range of the transfer function.
     float dst_range = dst.hdr.max_luma / MP_REF_WHITE;
-    if (mp_trc_is_hdr(dst.transfer))
-        dst_range = mp_trc_nom_peak(dst.transfer);
+    if (pl_color_space_is_hdr(&dst))
+        dst_range = pl_color_transfer_nominal_peak(dst.transfer);
 
     GLSLF("color.rgb *= vec3(%f);\n", 1.0 / dst_range);
 
@@ -1009,7 +1010,7 @@ void pass_sample_deband(struct gl_shader_cache *sc, struct deband_opts *opts,
     GLSL(noise.z = rand(h); h = permute(h);)
 
     // Noise is scaled to the signal level to prevent extreme noise for HDR
-    float gain = opts->grain/8192.0 / mp_trc_nom_peak(trc);
+    float gain = opts->grain/8192.0 / pl_color_transfer_nominal_peak(trc);
     GLSLF("color.xyz += %f * (noise - vec3(0.5));\n", gain);
     GLSLF("}\n");
 }