Skip to main content

sui_platform/
display_capabilities.rs

1use std::{
2    collections::HashMap,
3    sync::{OnceLock, RwLock},
4};
5
6use sui_core::WindowId;
7use sui_reactive::Signal;
8use sui_render_wgpu::{
9    DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS, DisplayCapabilities, DisplayColorPrimaries, OutputGamut,
10    OutputStrategy, TextSubpixelOrder,
11};
12use sui_runtime::{
13    WindowColorManagementMode, WindowDynamicRangeMode, WindowOutputColorPrimaries,
14    WindowToneMappingMode,
15};
16use winit::window::Window;
17
18#[cfg(target_os = "windows")]
19#[allow(unsafe_code)]
20mod windows_display;
21
22#[cfg(target_os = "linux")]
23#[allow(unsafe_code)]
24mod linux_text;
25
26#[cfg_attr(not(any(target_arch = "wasm32", test)), allow(dead_code))]
27#[derive(Debug, Clone, Copy, PartialEq, Default)]
28struct WebCapabilityHints {
29    force_sdr: bool,
30    wide_gamut: bool,
31    hdr: bool,
32    display_p3: bool,
33    float16_canvas: bool,
34    extended_tone_mapping: bool,
35    sdr_white_nits: Option<f32>,
36}
37
38#[derive(Debug, Clone, PartialEq)]
39pub struct WindowOutputDiagnostics {
40    pub display_capabilities: DisplayCapabilities,
41    pub requested_color_management_mode: WindowColorManagementMode,
42    pub requested_output_primaries: WindowOutputColorPrimaries,
43    pub requested_dynamic_range_mode: WindowDynamicRangeMode,
44    pub requested_tone_mapping_mode: WindowToneMappingMode,
45    pub requested_sdr_content_brightness_nits: f32,
46    pub configured_sdr_content_brightness_nits: f32,
47    pub system_sdr_content_brightness_nits: Option<f32>,
48    pub use_system_sdr_content_brightness: bool,
49    pub active_output_strategy: OutputStrategy,
50    /// The colors the output shows. `display_capabilities.preferred_primaries`
51    /// only says how output is encoded: native HDR output in sRGB primaries
52    /// shows wide-gamut colors on a wide-gamut display.
53    pub output_gamut: OutputGamut,
54}
55
56type DiagnosticsSignal = Signal<Option<WindowOutputDiagnostics>>;
57
58fn diagnostics_store() -> &'static RwLock<HashMap<WindowId, DiagnosticsSignal>> {
59    static STORE: OnceLock<RwLock<HashMap<WindowId, DiagnosticsSignal>>> = OnceLock::new();
60    STORE.get_or_init(|| RwLock::new(HashMap::new()))
61}
62
63/// Record the output diagnostics of the frame just presented for
64/// `window_id`. Widgets observing [`window_output_diagnostics_signal`] are
65/// invalidated when they differ from the last frame's.
66pub fn publish_window_output_diagnostics(
67    window_id: WindowId,
68    diagnostics: WindowOutputDiagnostics,
69) {
70    // Set outside the lock: observers run when the value changes.
71    window_output_diagnostics_signal(window_id).set(Some(diagnostics));
72}
73
74/// The output diagnostics of the last frame presented for `window_id`.
75pub fn window_output_diagnostics(window_id: WindowId) -> Option<WindowOutputDiagnostics> {
76    let store = diagnostics_store()
77        .read()
78        .expect("window output diagnostics store lock should not be poisoned");
79    store.get(&window_id).and_then(Signal::get)
80}
81
82/// The output diagnostics of `window_id` as a signal, for widgets that show
83/// them: observe it with `MeasureCtx::observe` or `PaintCtx::observe` to be
84/// invalidated when a presented frame's diagnostics change. It holds `None`
85/// until the window's first frame is presented.
86pub fn window_output_diagnostics_signal(window_id: WindowId) -> DiagnosticsSignal {
87    if let Some(signal) = diagnostics_store()
88        .read()
89        .expect("window output diagnostics store lock should not be poisoned")
90        .get(&window_id)
91    {
92        return signal.clone();
93    }
94    diagnostics_store()
95        .write()
96        .expect("window output diagnostics store lock should not be poisoned")
97        .entry(window_id)
98        .or_insert_with(|| Signal::named("Window output diagnostics", None))
99        .clone()
100}
101
102pub fn clear_window_output_diagnostics(window_id: WindowId) {
103    let removed = diagnostics_store()
104        .write()
105        .expect("window output diagnostics store lock should not be poisoned")
106        .remove(&window_id);
107    if let Some(signal) = removed {
108        signal.set(None);
109    }
110}
111
112pub fn clear_window_output_diagnostics_all() {
113    let removed = std::mem::take(
114        &mut *diagnostics_store()
115            .write()
116            .expect("window output diagnostics store lock should not be poisoned"),
117    );
118    for signal in removed.into_values() {
119        signal.set(None);
120    }
121}
122
123pub fn resolve_sdr_content_brightness_nits(
124    configured_nits: f32,
125    use_system_value: bool,
126    capabilities: &DisplayCapabilities,
127) -> f32 {
128    let configured = if configured_nits.is_finite() && configured_nits > 0.0 {
129        configured_nits
130    } else {
131        DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS
132    };
133
134    if use_system_value {
135        capabilities
136            .sdr_white_nits
137            .filter(|nits| nits.is_finite() && *nits > 0.0)
138            .unwrap_or(configured)
139    } else {
140        configured
141    }
142}
143
144#[cfg_attr(not(any(target_arch = "wasm32", test)), allow(dead_code))]
145fn parse_web_capability_hints(query: &str) -> WebCapabilityHints {
146    let mut hints = WebCapabilityHints::default();
147    for pair in query.trim_start_matches('?').split('&') {
148        if pair.is_empty() {
149            continue;
150        }
151        let mut parts = pair.splitn(2, '=');
152        let key = parts.next().unwrap_or_default();
153        let value = parts.next().unwrap_or_default();
154        match key {
155            "canvas-format" => {
156                if matches!(value, "rgba16float" | "float16" | "hdr") {
157                    hints.float16_canvas = true;
158                    hints.hdr = true;
159                } else if matches!(value, "rgba8unorm-srgb" | "srgb") {
160                    hints.force_sdr = true;
161                }
162            }
163            "canvas-color-space" => {
164                if matches!(value, "display-p3" | "p3") {
165                    hints.display_p3 = true;
166                    hints.wide_gamut = true;
167                }
168            }
169            "canvas-tone-mapping" => {
170                if matches!(value, "extended" | "hdr") {
171                    hints.extended_tone_mapping = true;
172                    hints.hdr = true;
173                } else if matches!(value, "standard") {
174                    hints.force_sdr = true;
175                }
176            }
177            "color-management" => match value {
178                "force-sdr" => {
179                    hints.force_sdr = true;
180                }
181                "prefer-wide-gamut" => {
182                    hints.wide_gamut = true;
183                }
184                "prefer-hdr" => {
185                    hints.wide_gamut = true;
186                    hints.hdr = true;
187                }
188                _ => {}
189            },
190            "output-primaries" => {
191                if matches!(value, "display-p3" | "p3") {
192                    hints.display_p3 = true;
193                    hints.wide_gamut = true;
194                }
195            }
196            "dynamic-range" => {
197                if matches!(value, "hdr" | "high") {
198                    hints.hdr = true;
199                } else if matches!(value, "sdr" | "standard") {
200                    hints.force_sdr = true;
201                }
202            }
203            "system-sdr-content-brightness" | "sdr-white-nits" => {
204                hints.sdr_white_nits = parse_positive_nits(value);
205            }
206            _ => {}
207        }
208    }
209
210    if hints.force_sdr {
211        hints.wide_gamut = false;
212        hints.hdr = false;
213        hints.display_p3 = false;
214        hints.float16_canvas = false;
215        hints.extended_tone_mapping = false;
216        hints.sdr_white_nits = None;
217    }
218
219    hints
220}
221
222#[cfg_attr(not(any(target_arch = "wasm32", test)), allow(dead_code))]
223fn parse_positive_nits(value: &str) -> Option<f32> {
224    value
225        .parse::<f32>()
226        .ok()
227        .filter(|nits| nits.is_finite() && *nits > 0.0)
228}
229
230#[cfg(target_arch = "wasm32")]
231fn web_media_query_matches(query: &str) -> bool {
232    web_sys::window()
233        .and_then(|window| window.match_media(query).ok().flatten())
234        .map(|media_query| media_query.matches())
235        .unwrap_or(false)
236}
237
238#[cfg_attr(not(any(target_arch = "wasm32", test)), allow(dead_code))]
239fn display_capabilities_from_web_signals(
240    monitor_name: &str,
241    hints: WebCapabilityHints,
242    media_wide_gamut: bool,
243    media_hdr: bool,
244) -> DisplayCapabilities {
245    let media_wide_gamut = !hints.force_sdr && media_wide_gamut;
246    let media_hdr = !hints.force_sdr && media_hdr;
247
248    DisplayCapabilities {
249        supports_wide_gamut: media_wide_gamut,
250        supports_hdr: media_hdr,
251        preferred_primaries: if media_wide_gamut {
252            DisplayColorPrimaries::DisplayP3
253        } else {
254            DisplayColorPrimaries::Srgb
255        },
256        preferred_dynamic_range: if media_hdr {
257            sui_render_wgpu::DynamicRangeMode::HighDynamicRange
258        } else {
259            sui_render_wgpu::DynamicRangeMode::StandardDynamicRange
260        },
261        sdr_white_nits: hints.sdr_white_nits,
262        native_hdr_presentation_supported: false,
263        notes: format!(
264            "Web output on {monitor_name}: query hints -> force_sdr={} float16_canvas={} display_p3={} extended_tone_mapping={} hdr={} sdr_white_nits={:?}; media queries -> wide_gamut={} hdr={}. WebGPU HDR canvas values are browser color-managed rather than native scRGB presentation. Browser APIs do not expose the OS SDR content brightness slider, so auto SDR brightness uses this explicit hint when present and otherwise falls back to the configured value.",
265            hints.force_sdr,
266            hints.float16_canvas,
267            hints.display_p3,
268            hints.extended_tone_mapping,
269            hints.hdr,
270            hints.sdr_white_nits,
271            media_wide_gamut,
272            media_hdr,
273        ),
274        ..DisplayCapabilities::default()
275    }
276}
277
278#[cfg(any(target_os = "windows", test))]
279const WINDOWS_SDR_REFERENCE_WHITE_NITS: f32 = 80.0;
280#[cfg(any(target_os = "windows", test))]
281const SRGB_PRIMARIES: [[f32; 2]; 3] = [[0.64, 0.33], [0.30, 0.60], [0.15, 0.06]];
282#[cfg(any(target_os = "windows", test))]
283const DISPLAY_P3_PRIMARIES: [[f32; 2]; 3] = [[0.68, 0.32], [0.265, 0.69], [0.15, 0.06]];
284
285#[cfg(any(target_os = "windows", test))]
286#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
287#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
288enum WindowsColorSpace {
289    #[default]
290    Srgb,
291    ScRgb,
292    Hdr10P2020,
293    Rgb2020,
294    Unknown,
295}
296
297#[cfg(any(target_os = "windows", test))]
298#[derive(Debug, Clone, PartialEq)]
299struct WindowsAdvancedColorInfo {
300    monitor_name: String,
301    device_name: Option<String>,
302    bits_per_color: u32,
303    color_space: WindowsColorSpace,
304    red_primary: Option<[f32; 2]>,
305    green_primary: Option<[f32; 2]>,
306    blue_primary: Option<[f32; 2]>,
307    white_point: Option<[f32; 2]>,
308    min_luminance_nits: Option<f32>,
309    max_luminance_nits: Option<f32>,
310    max_full_frame_luminance_nits: Option<f32>,
311    sdr_white_nits: Option<f32>,
312}
313
314#[cfg(any(target_os = "windows", test))]
315fn finite_positive(value: Option<f32>) -> Option<f32> {
316    value.filter(|value| value.is_finite() && *value > 0.0)
317}
318
319#[cfg(any(target_os = "windows", test))]
320fn primary_triplet(info: &WindowsAdvancedColorInfo) -> Option<[[f32; 2]; 3]> {
321    Some([info.red_primary?, info.green_primary?, info.blue_primary?])
322}
323
324#[cfg(any(target_os = "windows", test))]
325fn gamut_distance(primaries: [[f32; 2]; 3], reference: [[f32; 2]; 3]) -> f32 {
326    primaries
327        .into_iter()
328        .zip(reference)
329        .map(|(observed, expected)| {
330            let dx = observed[0] - expected[0];
331            let dy = observed[1] - expected[1];
332            dx * dx + dy * dy
333        })
334        .sum()
335}
336
337#[cfg(any(target_os = "windows", test))]
338fn looks_like_display_p3(info: &WindowsAdvancedColorInfo) -> bool {
339    let Some(primaries) = primary_triplet(info) else {
340        return false;
341    };
342    if primaries.iter().flatten().any(|value| !value.is_finite()) {
343        return false;
344    }
345    gamut_distance(primaries, DISPLAY_P3_PRIMARIES) < gamut_distance(primaries, SRGB_PRIMARIES)
346}
347
348#[cfg(any(target_os = "windows", test))]
349fn display_capabilities_from_windows_advanced_color_info(
350    info: &WindowsAdvancedColorInfo,
351) -> DisplayCapabilities {
352    let hdr_active = matches!(
353        info.color_space,
354        WindowsColorSpace::ScRgb | WindowsColorSpace::Hdr10P2020
355    );
356    let display_p3_like = looks_like_display_p3(info);
357    let supports_wide_gamut = hdr_active
358        || display_p3_like
359        || matches!(info.color_space, WindowsColorSpace::Rgb2020)
360        || info.bits_per_color > 8;
361    let max_luminance_nits = finite_positive(info.max_luminance_nits);
362    let max_full_frame_luminance_nits = finite_positive(info.max_full_frame_luminance_nits);
363    let min_luminance_nits = finite_positive(info.min_luminance_nits);
364    let detected_sdr_white_nits = finite_positive(info.sdr_white_nits);
365    let sdr_white_nits = hdr_active.then_some(detected_sdr_white_nits).flatten();
366    // Some Windows Advanced Color paths report 8 bpc even while presenting through
367    // an HDR-capable scRGB/PQ compositor path, so bpc is diagnostic rather than a
368    // native-HDR gate. The renderer still requires a float16 surface format.
369    let native_hdr_presentation_supported = hdr_active && sdr_white_nits.is_some();
370    let preferred_primaries = if hdr_active {
371        DisplayColorPrimaries::Srgb
372    } else if supports_wide_gamut {
373        DisplayColorPrimaries::DisplayP3
374    } else {
375        DisplayColorPrimaries::Srgb
376    };
377    let preferred_dynamic_range = if hdr_active {
378        sui_render_wgpu::DynamicRangeMode::HighDynamicRange
379    } else {
380        sui_render_wgpu::DynamicRangeMode::StandardDynamicRange
381    };
382    let sdr_reference_white_nits =
383        detected_sdr_white_nits.unwrap_or(WINDOWS_SDR_REFERENCE_WHITE_NITS);
384    let max_content_headroom = if hdr_active {
385        max_luminance_nits.map(|nits| nits / sdr_reference_white_nits)
386    } else {
387        None
388    };
389    let mode_summary = match info.color_space {
390        WindowsColorSpace::Hdr10P2020 => {
391            "Advanced Color enabled (PQ/P2020 monitor mode -> scRGB presentation path)"
392        }
393        WindowsColorSpace::ScRgb => "Advanced Color enabled (linear scRGB monitor mode)",
394        WindowsColorSpace::Rgb2020 => {
395            "Advanced Color disabled; monitor reports wide-gamut SDR primaries"
396        }
397        WindowsColorSpace::Srgb => {
398            if supports_wide_gamut {
399                "Advanced Color disabled; monitor looks like wide-gamut SDR"
400            } else {
401                "Advanced Color disabled; monitor reports SDR/sRGB"
402            }
403        }
404        WindowsColorSpace::Unknown => {
405            "Advanced Color state unknown; using conservative Windows capability mapping"
406        }
407    };
408    let gamut_summary = match preferred_primaries {
409        DisplayColorPrimaries::Srgb if hdr_active => {
410            "native HDR surface uses scRGB / P709 primaries"
411        }
412        DisplayColorPrimaries::DisplayP3 => {
413            "wide-gamut SDR path prefers Display-P3-style primaries"
414        }
415        DisplayColorPrimaries::Srgb => "SDR path prefers sRGB primaries",
416    };
417
418    DisplayCapabilities {
419        supports_wide_gamut,
420        supports_hdr: hdr_active,
421        preferred_primaries,
422        preferred_dynamic_range,
423        max_luminance_nits,
424        sdr_white_nits,
425        max_content_headroom,
426        native_hdr_presentation_supported,
427        notes: format!(
428            "Windows monitor {}{}: {}; {}; bits_per_color={}; sdr_white_nits={:?}; sdr_reference_white_nits={}; min_luminance_nits={:?}; max_full_frame_luminance_nits={:?}; white_point={:?}",
429            info.monitor_name,
430            info.device_name
431                .as_ref()
432                .map(|name| format!(" ({name})"))
433                .unwrap_or_default(),
434            mode_summary,
435            gamut_summary,
436            info.bits_per_color,
437            sdr_white_nits,
438            sdr_reference_white_nits,
439            min_luminance_nits,
440            max_full_frame_luminance_nits,
441            info.white_point,
442        ),
443        ..DisplayCapabilities::default()
444    }
445}
446
447/// The subpixel order the system's font smoothing antialiases text for. Only
448/// ClearType works per subpixel; standard smoothing and no smoothing are
449/// grayscale, as SUI's default is.
450#[cfg_attr(not(any(target_os = "windows", test)), allow(dead_code))]
451fn subpixel_order_for_font_smoothing(
452    enabled: bool,
453    cleartype: bool,
454    bgr: bool,
455) -> TextSubpixelOrder {
456    match (enabled && cleartype, bgr) {
457        (false, _) => TextSubpixelOrder::None,
458        (true, false) => TextSubpixelOrder::Rgb,
459        (true, true) => TextSubpixelOrder::Bgr,
460    }
461}
462
463#[cfg(target_os = "windows")]
464fn detect_windows_monitor_capabilities(
465    window: &Window,
466    monitor_name: &str,
467) -> Option<DisplayCapabilities> {
468    use self::windows_display::{
469        WindowsAdvancedColorProbe, WindowsAdvancedColorSpace, probe_monitor_for_hwnd,
470    };
471    use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
472
473    fn map_probe_color_space(color_space: WindowsAdvancedColorSpace) -> WindowsColorSpace {
474        match color_space {
475            WindowsAdvancedColorSpace::Srgb => WindowsColorSpace::Srgb,
476            WindowsAdvancedColorSpace::ScRgb => WindowsColorSpace::ScRgb,
477            WindowsAdvancedColorSpace::Hdr10P2020 => WindowsColorSpace::Hdr10P2020,
478            WindowsAdvancedColorSpace::Rgb2020 => WindowsColorSpace::Rgb2020,
479            WindowsAdvancedColorSpace::Unknown => WindowsColorSpace::Unknown,
480        }
481    }
482
483    let hwnd = match window.window_handle().ok()?.as_raw() {
484        RawWindowHandle::Win32(handle) => handle.hwnd.get(),
485        _ => return None,
486    };
487    let probe: WindowsAdvancedColorProbe = probe_monitor_for_hwnd(hwnd)?;
488    let info = WindowsAdvancedColorInfo {
489        monitor_name: monitor_name.to_string(),
490        device_name: probe.device_name,
491        bits_per_color: probe.bits_per_color,
492        color_space: map_probe_color_space(probe.color_space),
493        red_primary: probe.red_primary,
494        green_primary: probe.green_primary,
495        blue_primary: probe.blue_primary,
496        white_point: probe.white_point,
497        min_luminance_nits: probe.min_luminance_nits,
498        max_luminance_nits: probe.max_luminance_nits,
499        max_full_frame_luminance_nits: probe.max_full_frame_luminance_nits,
500        sdr_white_nits: probe.sdr_white_nits,
501    };
502    Some(display_capabilities_from_windows_advanced_color_info(&info))
503}
504
505pub fn detect_window_display_capabilities(window: &Window) -> DisplayCapabilities {
506    let monitor_name = window
507        .current_monitor()
508        .and_then(|monitor| monitor.name())
509        .unwrap_or_else(|| "unknown monitor".to_string());
510
511    #[cfg(target_os = "windows")]
512    {
513        let mut capabilities = detect_windows_monitor_capabilities(window, &monitor_name)
514            .unwrap_or_else(|| DisplayCapabilities {
515                supports_wide_gamut: false,
516                supports_hdr: false,
517                preferred_primaries: DisplayColorPrimaries::Srgb,
518                notes: format!(
519                    "Windows monitor {monitor_name}: DXGI Advanced Color probe failed; falling back to SDR/sRGB defaults"
520                ),
521                ..DisplayCapabilities::default()
522            });
523        capabilities.text_subpixel_order = windows_display::query_windows_font_smoothing().map_or(
524            TextSubpixelOrder::None,
525            |smoothing| {
526                subpixel_order_for_font_smoothing(
527                    smoothing.enabled,
528                    smoothing.cleartype,
529                    smoothing.bgr,
530                )
531            },
532        );
533        capabilities
534    }
535
536    #[cfg(target_os = "macos")]
537    {
538        DisplayCapabilities {
539            supports_wide_gamut: true,
540            supports_hdr: false,
541            preferred_primaries: DisplayColorPrimaries::DisplayP3,
542            notes: format!(
543                "macOS monitor {monitor_name}: conservative phase-2 heuristic assumes Display-P3 SDR; EDR headroom detection is not wired yet"
544            ),
545            ..DisplayCapabilities::default()
546        }
547    }
548
549    #[cfg(target_arch = "wasm32")]
550    {
551        let query = web_sys::window()
552            .and_then(|window| window.location().search().ok())
553            .unwrap_or_default();
554        let hints = parse_web_capability_hints(&query);
555        let media_wide_gamut = web_media_query_matches("(color-gamut: p3)")
556            || web_media_query_matches("(color-gamut: rec2020)");
557        let media_hdr = web_media_query_matches("(dynamic-range: high)");
558        display_capabilities_from_web_signals(&monitor_name, hints, media_wide_gamut, media_hdr)
559    }
560
561    #[cfg(target_os = "linux")]
562    {
563        use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
564        let x11 = window.window_handle().is_ok_and(|handle| {
565            matches!(
566                handle.as_raw(),
567                RawWindowHandle::Xlib(_) | RawWindowHandle::Xcb(_)
568            )
569        });
570        let text_subpixel_order = linux_text::query_text_subpixel_order(x11);
571        DisplayCapabilities {
572            text_subpixel_order,
573            notes: format!(
574                "Linux monitor {monitor_name}: SDR/sRGB defaults; system text smoothing {text_subpixel_order:?} (fontconfig/Xft)"
575            ),
576            ..DisplayCapabilities::default()
577        }
578    }
579
580    #[cfg(not(any(
581        target_os = "windows",
582        target_os = "macos",
583        target_os = "linux",
584        target_arch = "wasm32"
585    )))]
586    {
587        DisplayCapabilities {
588            supports_wide_gamut: false,
589            supports_hdr: false,
590            preferred_primaries: DisplayColorPrimaries::Srgb,
591            notes: format!(
592                "Monitor {monitor_name}: no native phase-2 capability probe for this platform yet; using SDR/sRGB defaults"
593            ),
594            ..DisplayCapabilities::default()
595        }
596    }
597}
598
599#[cfg(test)]
600mod tests {
601    use super::{
602        DisplayColorPrimaries, WindowsAdvancedColorInfo, WindowsColorSpace,
603        display_capabilities_from_web_signals,
604        display_capabilities_from_windows_advanced_color_info, parse_web_capability_hints,
605    };
606    use sui_render_wgpu::{DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS, DynamicRangeMode};
607
608    #[test]
609    fn only_cleartype_smoothing_selects_a_subpixel_order() {
610        use super::subpixel_order_for_font_smoothing as order;
611        use sui_render_wgpu::TextSubpixelOrder;
612
613        assert_eq!(order(true, true, false), TextSubpixelOrder::Rgb);
614        assert_eq!(order(true, true, true), TextSubpixelOrder::Bgr);
615        // Standard (grayscale) smoothing, or smoothing turned off.
616        assert_eq!(order(true, false, false), TextSubpixelOrder::None);
617        assert_eq!(order(false, true, false), TextSubpixelOrder::None);
618    }
619
620    #[test]
621    fn parse_web_capability_hints_detects_phase4_query_preferences() {
622        let hints = parse_web_capability_hints(
623            "?canvas-format=float16&canvas-color-space=display-p3&canvas-tone-mapping=extended&color-management=prefer-hdr&dynamic-range=hdr&system-sdr-content-brightness=240",
624        );
625
626        assert!(hints.float16_canvas);
627        assert!(hints.display_p3);
628        assert!(hints.extended_tone_mapping);
629        assert!(hints.wide_gamut);
630        assert!(hints.hdr);
631        assert_eq!(hints.sdr_white_nits, Some(240.0));
632    }
633
634    #[test]
635    fn parse_web_capability_hints_treats_prefer_hdr_as_hdr() {
636        let hints = parse_web_capability_hints("?color-management=prefer-hdr");
637
638        assert!(hints.wide_gamut);
639        assert!(hints.hdr);
640    }
641
642    #[test]
643    fn parse_web_capability_hints_force_sdr_suppresses_hdr_hints() {
644        let hints = parse_web_capability_hints(
645            "?color-management=force-sdr&canvas-format=rgba16float&canvas-color-space=display-p3&canvas-tone-mapping=extended&dynamic-range=hdr",
646        );
647
648        assert!(hints.force_sdr);
649        assert!(!hints.float16_canvas);
650        assert!(!hints.display_p3);
651        assert!(!hints.extended_tone_mapping);
652        assert!(!hints.wide_gamut);
653        assert!(!hints.hdr);
654        assert_eq!(hints.sdr_white_nits, None);
655    }
656
657    #[test]
658    fn web_capabilities_do_not_treat_hdr_query_as_hdr_support() {
659        let hints = parse_web_capability_hints(
660            "?color-management=prefer-hdr&canvas-format=rgba16float&canvas-tone-mapping=extended&dynamic-range=hdr",
661        );
662        let capabilities = display_capabilities_from_web_signals("browser", hints, true, false);
663
664        assert!(capabilities.supports_wide_gamut);
665        assert!(!capabilities.supports_hdr);
666        assert!(!capabilities.native_hdr_presentation_supported);
667        assert_eq!(
668            capabilities.preferred_dynamic_range,
669            DynamicRangeMode::StandardDynamicRange
670        );
671    }
672
673    #[test]
674    fn web_capabilities_use_hdr_media_query_for_hdr_support() {
675        let hints = parse_web_capability_hints("?color-management=automatic");
676        let capabilities = display_capabilities_from_web_signals("browser", hints, true, true);
677
678        assert!(capabilities.supports_wide_gamut);
679        assert!(capabilities.supports_hdr);
680        assert!(!capabilities.native_hdr_presentation_supported);
681        assert_eq!(capabilities.sdr_white_nits, None);
682        assert_eq!(
683            capabilities.preferred_dynamic_range,
684            DynamicRangeMode::HighDynamicRange
685        );
686        assert!(capabilities.notes.contains("browser color-managed"));
687    }
688
689    #[test]
690    fn web_capabilities_use_explicit_sdr_white_hint_for_auto_brightness() {
691        let hints = parse_web_capability_hints("?sdr-white-nits=260");
692        let capabilities = display_capabilities_from_web_signals("browser", hints, true, true);
693
694        assert_eq!(capabilities.sdr_white_nits, Some(260.0));
695        assert!(capabilities.notes.contains("sdr_white_nits=Some(260.0)"));
696    }
697
698    #[test]
699    fn web_capabilities_force_sdr_suppresses_media_hdr() {
700        let hints = parse_web_capability_hints("?color-management=force-sdr");
701        let capabilities = display_capabilities_from_web_signals("browser", hints, true, true);
702
703        assert!(!capabilities.supports_wide_gamut);
704        assert!(!capabilities.supports_hdr);
705        assert!(!capabilities.native_hdr_presentation_supported);
706        assert_eq!(
707            capabilities.preferred_dynamic_range,
708            DynamicRangeMode::StandardDynamicRange
709        );
710    }
711
712    #[test]
713    fn windows_hdr_advanced_color_maps_to_scrgb_capabilities() {
714        let capabilities =
715            display_capabilities_from_windows_advanced_color_info(&WindowsAdvancedColorInfo {
716                monitor_name: "HDR Panel".to_string(),
717                device_name: Some("\\\\.\\DISPLAY1".to_string()),
718                bits_per_color: 10,
719                color_space: WindowsColorSpace::Hdr10P2020,
720                red_primary: Some([0.68, 0.32]),
721                green_primary: Some([0.265, 0.69]),
722                blue_primary: Some([0.15, 0.06]),
723                white_point: Some([0.3127, 0.3290]),
724                min_luminance_nits: Some(0.05),
725                max_luminance_nits: Some(1000.0),
726                max_full_frame_luminance_nits: Some(600.0),
727                sdr_white_nits: Some(203.0),
728            });
729
730        assert!(capabilities.supports_hdr);
731        assert!(capabilities.native_hdr_presentation_supported);
732        assert!(capabilities.supports_wide_gamut);
733        assert_eq!(
734            capabilities.preferred_primaries,
735            DisplayColorPrimaries::Srgb
736        );
737        assert_eq!(
738            capabilities.preferred_dynamic_range,
739            DynamicRangeMode::HighDynamicRange
740        );
741        assert_eq!(capabilities.sdr_white_nits, Some(203.0));
742        assert_eq!(capabilities.max_content_headroom, Some(1000.0 / 203.0));
743        assert!(capabilities.notes.contains("Advanced Color"));
744        assert!(capabilities.notes.contains("scRGB"));
745        assert!(capabilities.notes.contains("sdr_white_nits=Some(203.0)"));
746    }
747
748    #[test]
749    fn windows_hdr_without_sdr_white_avoids_native_hdr_presentation() {
750        let capabilities =
751            display_capabilities_from_windows_advanced_color_info(&WindowsAdvancedColorInfo {
752                monitor_name: "HDR Panel".to_string(),
753                device_name: Some("\\\\.\\DISPLAY1".to_string()),
754                bits_per_color: 10,
755                color_space: WindowsColorSpace::Hdr10P2020,
756                red_primary: Some([0.68, 0.32]),
757                green_primary: Some([0.265, 0.69]),
758                blue_primary: Some([0.15, 0.06]),
759                white_point: Some([0.3127, 0.3290]),
760                min_luminance_nits: Some(0.05),
761                max_luminance_nits: Some(1000.0),
762                max_full_frame_luminance_nits: Some(600.0),
763                sdr_white_nits: None,
764            });
765
766        assert!(capabilities.supports_hdr);
767        assert!(!capabilities.native_hdr_presentation_supported);
768        assert_eq!(capabilities.sdr_white_nits, None);
769        assert!(capabilities.notes.contains("sdr_white_nits=None"));
770    }
771
772    #[test]
773    fn windows_hdr_with_sdr_white_allows_native_hdr_even_when_reported_bpc_is_8() {
774        let capabilities =
775            display_capabilities_from_windows_advanced_color_info(&WindowsAdvancedColorInfo {
776                monitor_name: "HDR Panel".to_string(),
777                device_name: Some("\\\\.\\DISPLAY4".to_string()),
778                bits_per_color: 8,
779                color_space: WindowsColorSpace::Hdr10P2020,
780                red_primary: Some([0.708, 0.292]),
781                green_primary: Some([0.17, 0.797]),
782                blue_primary: Some([0.131, 0.046]),
783                white_point: Some([0.3125, 0.3291]),
784                min_luminance_nits: Some(0.1009),
785                max_luminance_nits: Some(500.0),
786                max_full_frame_luminance_nits: Some(400.0),
787                sdr_white_nits: Some(220.0),
788            });
789
790        assert!(capabilities.supports_hdr);
791        assert!(capabilities.native_hdr_presentation_supported);
792        assert_eq!(capabilities.sdr_white_nits, Some(220.0));
793        assert!(capabilities.notes.contains("bits_per_color=8"));
794        assert!(capabilities.notes.contains("sdr_white_nits=Some(220.0)"));
795    }
796
797    #[test]
798    fn windows_sdr_display_p3_monitor_maps_to_wide_gamut_sdr_capabilities() {
799        let capabilities =
800            display_capabilities_from_windows_advanced_color_info(&WindowsAdvancedColorInfo {
801                monitor_name: "Wide Gamut SDR".to_string(),
802                device_name: Some("\\\\.\\DISPLAY2".to_string()),
803                bits_per_color: 8,
804                color_space: WindowsColorSpace::Srgb,
805                red_primary: Some([0.68, 0.32]),
806                green_primary: Some([0.265, 0.69]),
807                blue_primary: Some([0.15, 0.06]),
808                white_point: Some([0.3127, 0.3290]),
809                min_luminance_nits: None,
810                max_luminance_nits: Some(300.0),
811                max_full_frame_luminance_nits: Some(280.0),
812                sdr_white_nits: None,
813            });
814
815        assert!(capabilities.supports_wide_gamut);
816        assert!(!capabilities.supports_hdr);
817        assert!(!capabilities.native_hdr_presentation_supported);
818        assert_eq!(
819            capabilities.preferred_primaries,
820            DisplayColorPrimaries::DisplayP3
821        );
822        assert_eq!(
823            capabilities.preferred_dynamic_range,
824            DynamicRangeMode::StandardDynamicRange
825        );
826        assert!(capabilities.notes.contains("wide-gamut SDR"));
827    }
828
829    #[test]
830    fn default_sdr_brightness_resolves_to_detected_display_white() {
831        let capabilities = sui_render_wgpu::DisplayCapabilities {
832            sdr_white_nits: Some(240.0),
833            ..sui_render_wgpu::DisplayCapabilities::default()
834        };
835
836        assert_eq!(
837            super::resolve_sdr_content_brightness_nits(
838                DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS,
839                true,
840                &capabilities
841            ),
842            240.0
843        );
844        assert_eq!(
845            super::resolve_sdr_content_brightness_nits(180.0, true, &capabilities),
846            240.0
847        );
848        assert_eq!(
849            super::resolve_sdr_content_brightness_nits(180.0, false, &capabilities),
850            180.0
851        );
852    }
853
854    #[test]
855    fn default_sdr_brightness_keeps_configured_value_without_detection() {
856        let capabilities = sui_render_wgpu::DisplayCapabilities {
857            supports_hdr: true,
858            sdr_white_nits: None,
859            ..sui_render_wgpu::DisplayCapabilities::default()
860        };
861
862        assert_eq!(
863            super::resolve_sdr_content_brightness_nits(
864                DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS,
865                true,
866                &capabilities
867            ),
868            DEFAULT_SDR_CONTENT_BRIGHTNESS_NITS
869        );
870    }
871}