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