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 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}