vo_gpu_next: linearize sRGB as a pure 2.2 power function

sRGB reference display is defined a 2.2 gamma device. To preserve the
look of the sRGB as mastered on such device, linearize it as such.

Note that sRGB encoding is piecewise with linear segment, which creates
mismatch to pure power 2.2 function, but this is intended to be viewed
on such display.

See:
IEC 61966-2-1-1999
https://community.acescentral.com/t/srgb-piece-wise-eotf-vs-pure-gamma/4024
KhronosGroup/DataFormat#19
https://gitlab.freedesktop.org/pq/color-and-hdr/-/issues/12
https://github.com/dylanraga/win11hdr-srgb-to-gamma2.2-icm

Author: kasper93

DOCS/man/options.rst

@@ -7354,6 +7354,20 @@ them.
         transfer function is SDR. This way you can control SDR output separately
         from HDR output.
 
+``--treat-srgb-as-power22=<no|input|output|both>``
+    When enabled, sRGB is (de)linearized using a pure power 2.2 curve instead of
+    the standard sRGB piecewise transfer function. The sRGB reference display is
+    defined as having a 2.2 power response. Enabling this option preserves the
+    intended visual appearance of sRGB content as it was mastered on such displays.
+    This option affects both input and output sRGB handling.
+    Default: ``both``. (Only for ``--vo=gpu-next``)
+
+    See for more details:
+    https://community.acescentral.com/t/srgb-piece-wise-eotf-vs-pure-gamma/4024
+    https://github.com/KhronosGroup/DataFormat/issues/19
+    https://gitlab.freedesktop.org/pq/color-and-hdr/-/issues/12
+    https://github.com/dylanraga/win11hdr-srgb-to-gamma2.2-icm
+
 ``--tone-mapping=<value>``
     Specifies the algorithm used for tone-mapping images onto the target
     display. This is relevant for both HDR->SDR conversion as well as gamut

video/out/gpu/video.c

@@ -409,6 +409,7 @@ static const struct gl_video_opts gl_video_opts_def = {
     .early_flush = -1,
     .shader_cache = true,
     .hwdec_interop = "auto",
+    .treat_srgb_as_power22 = 3, // both
 };
 
 static OPT_STRING_VALIDATE_FUNC(validate_error_diffusion_opt);
@@ -445,6 +446,8 @@ const struct m_sub_options gl_video_conf = {
             M_RANGE(10, 10000)},
         {"hdr-reference-white", OPT_CHOICE(hdr_reference_white, {"auto", 0}),
             M_RANGE(10, 10000)},
+        {"treat-srgb-as-power22", OPT_CHOICE(treat_srgb_as_power22,
+            {"no", 0}, {"input", 1}, {"output", 2}, {"both", 3})},
         {"target-contrast", OPT_CHOICE(target_contrast, {"auto", 0}, {"inf", -1}),
             M_RANGE(10, 1000000)},
         {"target-gamut", OPT_CHOICE_C(target_gamut, pl_csp_prim_names)},

video/out/gpu/video.h

@@ -139,6 +139,7 @@ struct gl_video_opts {
     int target_trc;
     int target_peak;
     int hdr_reference_white;
+    int treat_srgb_as_power22;
     int target_contrast;
     int target_gamut;
     struct gl_tone_map_opts tone_map;

video/out/vo_gpu_next.c

@@ -675,6 +675,13 @@ static bool map_frame(pl_gpu gpu, pl_tex *tex, const struct pl_source_frame *src
     if (opts->hdr_reference_white && !pl_color_transfer_is_hdr(frame->color.transfer))
         frame->color.hdr.max_luma = opts->hdr_reference_white;
 
+
+    if (opts->treat_srgb_as_power22 & 1 && frame->color.transfer == PL_COLOR_TRC_SRGB) {
+        // The sRGB EOTF is a pure gamma 2.2 function. See reference display in
+        // IEC 61966-2-1-1999. Linearize sRGB to display light.
+        frame->color.transfer = PL_COLOR_TRC_GAMMA22;
+    }
+
     if (fp->hwdec) {
 
         struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(par.imgfmt);
@@ -1213,6 +1220,11 @@ static bool draw_frame(struct vo *vo, struct vo_frame *frame)
         // Update again after possible max_luma change
         if (p->icc_profile)
             hint = p->icc_profile->csp;
+        // If preferred transfer is gamma 2.2, which is not defined as Vulkan
+        // swapchain colorspace, use sRGB instead. It has reference display with
+        // gamma 2.2 so it's the same target in practice.
+        if (hint.transfer == PL_COLOR_TRC_GAMMA22)
+            hint.transfer = PL_COLOR_TRC_SRGB;
         if (!pass_colorspace)
             pl_swapchain_colorspace_hint(p->sw, &hint);
     } else if (!target_hint) {
@@ -1247,6 +1259,9 @@ static bool draw_frame(struct vo *vo, struct vo_frame *frame)
     pl_frame_from_swapchain(&target, &swframe);
     bool strict_sw_params = target_hint && !pass_colorspace && p->next_opts->target_hint_strict;
     apply_target_options(p, &target, hint.hdr.min_luma, strict_sw_params);
+    // sRGB reference display is pure 2.2 power function, see IEC 61966-2-1-1999.
+    if (opts->treat_srgb_as_power22 & 3 && target.color.transfer == PL_COLOR_TRC_SRGB)
+        target.color.transfer = PL_COLOR_TRC_GAMMA22;
     update_overlays(vo, p->osd_res,
                     (frame->current && opts->blend_subs) ? OSD_DRAW_OSD_ONLY : 0,
                     PL_OVERLAY_COORDS_DST_FRAME, &p->osd_state, &target, frame->current);
@@ -1618,10 +1633,22 @@ static void video_screenshot(struct vo *vo, struct voctrl_screenshot *args)
     if (args->scaled) {
         // Apply target LUT, ICC profile and CSP override only in window mode
         apply_target_options(p, &target, 0, false);
+        // sRGB reference display is pure 2.2 power function, see IEC 61966-2-1-1999.
+        // Round-trip back to sRGB if the source is also sRGB.
+        if (opts->treat_srgb_as_power22 & 1 &&
+            target.color.transfer == PL_COLOR_TRC_SRGB &&
+            mpi->params.color.transfer == PL_COLOR_TRC_SRGB)
+        {
+            target.color.transfer = PL_COLOR_TRC_GAMMA22;
+        }
     } else if (args->native_csp) {
         target.color = image.color;
     } else {
-        target.color = pl_color_space_srgb;
+        target.color = (struct pl_color_space){
+            .primaries = PL_COLOR_PRIM_BT_709,
+            .transfer = opts->treat_srgb_as_power22 & 2 ? PL_COLOR_TRC_GAMMA22
+                                                        : PL_COLOR_TRC_SRGB,
+        };
     }
 
     apply_crop(&image, src, mpi->params.w, mpi->params.h);