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