TASK 51 blur 'heavy' fix: quadratic blur radius. BlurRadius(strength) = 1 + 5s^2, MaxBlurRadius 12 -> 6 downscaled px (~24 full px max). Default 0.5 is now radius 2 small px (was the old linear 6) - ~3x lighter perceived spread, matching the creator's real-camera finding. Range from the established tools: StreamFX defaults its Box blur Size to 5 and its author stops downscale-based blurs around 8px. One integration test pins the mapping (0 -> 1, 0.5 -> 2, 1 -> 6) and step-edge behaviour (light reaches 9px at default vs 26px at full); the existing slice-2 blur test passes unchanged. 419/419 pass. Refs: https://github.com/Vhonowslend/StreamFX-Public/wiki/Filter-Blur https://xaymar.com/articles/2020/04/26/optimizing-streamfx-in-your-obs-scenes/ (Unit: bg-blur heavy fix)

Services/BackgroundEffects/BackgroundEffectProcessor.cs

@@ -32,9 +32,12 @@ public sealed class BackgroundEffectProcessor
     /// upsampled while blending — a strong blur at a fraction of the cost.</summary>
     internal const int BlurDownscale = 4;
 
-    /// <summary>Box-blur radius (in downscaled pixels) at strength 0 and 1.</summary>
+    /// <summary>Box-blur radius (in downscaled pixels) at strength 0 and 1. The maximum was halved
+    /// from 12 (2026-10-09): the creator found full range too heavy — the old max spread ≈48 full
+    /// px. The established tools blur far less: StreamFX defaults its Box blur size to 5 and its
+    /// author stops downscale-based blurs around 8 px.</summary>
     internal const int MinBlurRadius = 1;
-    internal const int MaxBlurRadius = 12;
+    internal const int MaxBlurRadius = 6;
 
     private readonly IPersonSegmenter _segmenter;
     private bool _loggedFailure;
@@ -161,7 +164,7 @@ public sealed class BackgroundEffectProcessor
         });
 
         // 2. Three separable box-blur passes ≈ a gaussian.
-        var radius = (int)Math.Round(MinBlurRadius + (MaxBlurRadius - MinBlurRadius) * strength);
+        var radius = BlurRadius(strength);
         var scratch = new float[small.Length];
         for (var pass = 0; pass < 3; pass++)
         {
@@ -212,6 +215,15 @@ public sealed class BackgroundEffectProcessor
         return new VideoFrame(width, height, dst) { Epoch = frame.Epoch, IsOpaque = frame.IsOpaque };
     }
 
+    /// <summary>Blur radius in downscaled pixels for a strength. Quadratic (s²), not linear, so the
+    /// default 0.5 stays gentle (2 small px ≈ ~8–10 full px of perceived spread, ~3× lighter than
+    /// the old linear 6) while only the top of the slider approaches the full range.</summary>
+    internal static int BlurRadius(double strength)
+    {
+        var s = Math.Clamp(strength, 0, 1);
+        return (int)Math.Round(MinBlurRadius + (MaxBlurRadius - MinBlurRadius) * s * s);
+    }
+
     /// <summary>Row-parallel pixel loops, capped so the effect worker can't starve the compositor
     /// and encoder threads.</summary>
     private static readonly ParallelOptions RowParallelism = new()

Services/index.md

@@ -20,7 +20,7 @@ External-facing logic: YouTube API, persistence. See
 | `BackgroundEffects/IPersonSegmenter.cs` | **TASK 51 seam:** `Segment(VideoFrame) → SegmentationMask?` (`SegmentationMask(Width, Height, float[] Values)`, 0 = background, 1 = person); null = no mask → caller passes through. Tests inject fakes |
 | `BackgroundEffects/OnnxPersonSegmenter.cs` | **TASK 51 default segmenter:** MediaPipe Selfie Segmenter (landscape, Apache-2.0) as an embedded ONNX resource, run by onnxruntime on the CPU (2 intra-op threads); frame stretched to 256×144 RGB/255 NHWC; lazy session; never throws (fail → log once, null forever) |
 | `BackgroundEffects/WebcamEffectKey.cs` | **TASK 51:** `(Effect, Strength)` variant key, strength rounded to 0.01; `None` normalizes to strength 0 (the raw path) |
-| `BackgroundEffects/BackgroundEffectProcessor.cs` | **TASK 51 pure pixel stage:** `Apply(frame, BackgroundEffect)` — None = same instance, Remove = copy with alpha = feathered mask × source alpha (`IsOpaque=false`), Blur = background blurred at ¼ res (3 box passes) and mask-blended, person untouched; strength 0..1; `TrySegment` once + `Render` per effect; no mask/exception → passthrough + one log |
+| `BackgroundEffects/BackgroundEffectProcessor.cs` | **TASK 51 pure pixel stage:** `Apply(frame, BackgroundEffect)` — None = same instance, Remove = copy with alpha = feathered mask × source alpha (`IsOpaque=false`), Blur = background blurred at ¼ res (3 box passes) and mask-blended, person untouched; strength 0..1; blur radius is **quadratic** via `BlurRadius(strength)` — 1→6 small px (default 0.5 = 2, was a linear 1→12 ≈ 48 full px; the "blur heavy" fix 2026-10-09); `TrySegment` once + `Render` per effect; no mask/exception → passthrough + one log |
 | `BackgroundEffects/MaskSmoother.cs` | **TASK 51 jitter fix (2026-10-09):** temporally blends each raw mask with the previous smoothed one — `CurrentWeight` 0.75 × new + 0.25 × previous — so a per-frame segmentation verdict that wavers at an edge doesn't flutter the cut-out. Null input resets history; first frame/size change pass through; the returned mask never aliases the caller's array and the two buffers ping-pong (no per-frame LOH alloc: a 256×144 mask is 147 KB). State is **per camera session**, not in the segmenter (which is shared app-wide and contract-pinned to raw output). Weights from the OBS/Jitsi consensus — see `ai.md` "Webcam background effects" |
 | `CameraDeviceInfo.cs` | `(Id, DisplayName)` for a physical capture device |
 | `ICameraEnumerator.cs` | `GetCamerasAsync()` — seam so the picker/`CameraManager` never touch WinRT (tests inject fakes) |