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