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 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
59pub fn publish_window_output_diagnostics(
63 window_id: WindowId,
64 diagnostics: WindowOutputDiagnostics,
65) {
66 window_output_diagnostics_signal(window_id).set(Some(diagnostics));
68}
69
70pub 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
78pub 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 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}