blur: bridge SDR/PQ in blend shader and FP16-back saved_pixels on HDR

Two HDR-output regressions surfaced after the zero-copy bypass and
luminance multiplier work, both rooted in blur's two-input pipeline.

1. blend shader was super bright on HDR. wp comes from inner_content
   (EXT_LINEAR / SDR-relative linear, 1.0 == SDR reference white).
   bp comes from sampling the blurred copy of target_fb's bound FBO,
   which on HDR is PQ-linear (1.0 == 10000 nits). The blend then
   wrote into target_fb in PQ-linear without bridging the wp side, so
   SDR window content landed at 1.0 PQ-linear and showed as 10000-nit
   white. Add a luminance_multiplier uniform to the blur_blend
   fragment shader, scale wp.rgb by it, and have wf_blur_base::render
   compute the factor with wf::compute_luminance_multiplier(EXT_LINEAR,
   target_fb.get_output_transfer_function()) — 1.0 on SDR, 0.0203 on
   HDR.

2. White rectangles on the padded regions around blurred windows.
   schedule_instructions glBlitFramebuffers a snippet of target's
   bound FBO into saved_pixels->pixels, which was allocated as 8-bit
   RGBA. With the linear two-pass pipeline target's FBO is FP16, and
   on HDR it carries PQ-linear values that can exceed 1.0 for HDR
   sources. Blitting to RGBA8 clamped those to 1.0 == peak HDR white;
   on the way back into target's FBO they painted as solid bright
   white over the padding. Allocate saved_pixels with hdr_linear hint
   when target's transfer function is PQ so the snapshot is FP16 and
   round-trips losslessly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kode54

plugins/blur/blur-base.cpp

@@ -35,6 +35,7 @@ precision highp float;
 
 @builtin@
 uniform float sat;
+uniform float luminance_multiplier;
 uniform sampler2D bg_texture;
 
 varying highp vec2 uvpos[2];
@@ -52,6 +53,9 @@ void main()
     vec4 bp = texture2D(bg_texture, uvpos[1]);
     bp = vec4(saturation(bp.rgb, sat), bp.a);
     vec4 wp = get_pixel(uvpos[0]);
+    // wp comes from inner_content in EXT_LINEAR (SDR-relative) space; bp comes from the target FBO
+    // which is PQ-linear on HDR outputs. Bring wp into the same domain as bp before blending.
+    wp.rgb *= luminance_multiplier;
     vec4 c = clamp(4.0 * wp.a, 0.0, 1.0) * bp;
     gl_FragColor = wp + (1.0 - wp.a) * c;
 })";
@@ -277,6 +281,10 @@ void wf_blur_base::render(wf::gles_texture_t src_tex, wlr_box src_box, const wf:
     /* XXX: core should give us the number of texture units used */
     blend_program.uniform1i("bg_texture", 1);
     blend_program.uniform1f("sat", saturation_opt);
+    // Bridge SDR-relative linear (src_tex / inner_content) into the target's domain. On HDR outputs
+    // the bound FBO is PQ-linear; on SDR the multiplier is 1.0 so this is a no-op.
+    blend_program.uniform1f("luminance_multiplier", wf::compute_luminance_multiplier(
+        WLR_COLOR_TRANSFER_FUNCTION_EXT_LINEAR, target_fb.get_output_transfer_function()));
 
     blend_program.set_active_texture(src_tex);
     GL_CALL(glActiveTexture(GL_TEXTURE0 + 1));

plugins/blur/blur.cpp

@@ -174,7 +174,15 @@ class blur_render_instance_t : public transformer_render_instance_t<blur_node_t>
         // Nodes below should re-render the padded areas so that we can sample from them
         damage |= padded_region;
 
-        saved_pixels->pixels.allocate(target.get_size());
+        // saved_pixels is filled by glBlitFramebuffer'ing target's bound FBO. With wlroots GLES2's
+        // linear two-pass pipeline that source FBO is FP16 — PQ-linear on HDR outputs, where HDR
+        // window content reaches values > 1.0. An 8-bit RGBA backing would clamp those to 1.0 (peak
+        // HDR white) and then blit-back would deposit stark white over the padded regions. Mirror
+        // the source format on HDR by hinting hdr_linear so the saved_pixels buffer is FP16 too.
+        const bool target_is_hdr = target.get_output_transfer_function() ==
+            WLR_COLOR_TRANSFER_FUNCTION_ST2084_PQ;
+        saved_pixels->pixels.allocate(target.get_size(), 1.0f,
+            wf::buffer_allocation_hints_t{.hdr_linear = target_is_hdr});
 
         wf::gles::run_in_context_if_gles([&]
         {