diff --git a/README.md b/README.md index ae1a0b4..4eda770 100644 --- a/README.md +++ b/README.md @@ -94,6 +94,10 @@ reading or changing a real monitor. `Switch` only selects modes already exposed by DRM/Hyprland. It does not make a new EDID mode appear. +Export writes the current working EDID. With no pending changes, it asks you to +make an edit before writing any files. VRR edits and stereo cleanup also count +as pending changes. + ## What It Can Edit - Established timing inspection diff --git a/src/edid.rs b/src/edid.rs index 7528c86..212407d 100644 --- a/src/edid.rs +++ b/src/edid.rs @@ -711,6 +711,7 @@ fn repair_block_checksum(block: &mut [u8]) { /// Remove stereoscopic DTD flags from a desktop EDID override. Preserve sync, /// interlace, monitor descriptors, data blocks, and unsupported extensions. +/// Bit 0 only selects a stereo format when bits 6:5 are nonzero. pub fn clear_detailed_timing_stereo(raw: &mut [u8]) -> usize { if raw.len() < BASE_BLOCK_LEN || raw[..8] != HEADER { return 0; @@ -733,7 +734,7 @@ pub fn clear_detailed_timing_stereo(raw: &mut [u8]) -> usize { }; let mut changed = false; for descriptor in block[range].chunks_exact_mut(DTD_LEN) { - if (descriptor[0] != 0 || descriptor[1] != 0) && descriptor[17] & 0x61 != 0 { + if (descriptor[0] != 0 || descriptor[1] != 0) && descriptor[17] & 0x60 != 0 { descriptor[17] &= !0x61; cleared += 1; changed = true; @@ -1468,7 +1469,7 @@ mod tests { #[test] fn clears_all_stereo_encodings_without_changing_other_dtd_fields() { - for stereo in [0x01, 0x20, 0x21, 0x40, 0x41, 0x60, 0x61] { + for stereo in [0x20, 0x21, 0x40, 0x41, 0x60, 0x61] { let mut raw = minimal_base_edid(1); let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); descriptor[17] = 0x9e | stereo; @@ -1499,6 +1500,53 @@ mod tests { } } + #[test] + fn non_stereo_dtd_flags_and_checksums_are_preserved() { + let mut raw = minimal_base_edid(1); + for (slot, flags) in [0x19, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = DTD_START + slot * DTD_LEN; + raw[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut raw); + let mut cta = vec![0; EDID_BLOCK_LEN]; + cta[0] = CTA_TAG; + cta[1] = 3; + cta[2] = 4; + for (slot, flags) in [0x19, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = 4 + slot * DTD_LEN; + cta[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut cta); + raw.extend_from_slice(&cta); + let before = raw.clone(); + + assert_eq!(clear_detailed_timing_stereo(&mut raw), 0); + assert_eq!(raw, before); + assert!(raw.chunks_exact(EDID_BLOCK_LEN).all(block_checksum_valid)); + } + + #[test] + fn stereo_cleanup_preserves_adjacent_non_stereo_dtds() { + let mut raw = minimal_base_edid(0); + for (slot, flags) in [0x19, 0x7b, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = DTD_START + slot * DTD_LEN; + raw[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut raw); + let mut expected = raw.clone(); + expected[DTD_START + DTD_LEN + 17] = 0x1a; + repair_block_checksum(&mut expected); + + assert_eq!(clear_detailed_timing_stereo(&mut raw), 1); + assert_eq!(raw, expected); + } + #[test] fn displayid_product_id_does_not_hide_following_timings() { let mut edid = minimal_base_edid(1); diff --git a/src/export.rs b/src/export.rs index eee9a52..6404553 100644 --- a/src/export.rs +++ b/src/export.rs @@ -1,74 +1,24 @@ -use crate::edid::{DtdLocation, EdidError, insert_detailed_timing}; use crate::hyprland_config; -use crate::models::{ExportPlan, Monitor, TimingDescriptor}; +use crate::models::{ExportPlan, Monitor}; use crate::workspace::EdidWorkspace; use std::fs; use std::io; use std::path::{Path, PathBuf}; use thiserror::Error; -pub fn build_export_plan_with_file( - connector: impl Into, - edid_file_name: impl Into, - timing: TimingDescriptor, -) -> ExportPlan { - let connector = connector.into(); - let hyprland_mode = timing.hyprland_mode(); - ExportPlan { - hyprland_rule: format!("monitor={connector},{hyprland_mode},auto,1"), - connector, - edid_file_name: edid_file_name.into(), - hyprland_mode, - position: "auto".to_string(), - scale: "1".to_string(), - } -} - #[derive(Debug, Clone, PartialEq)] pub struct ExportResult { pub path: PathBuf, pub instructions_path: PathBuf, pub plan: ExportPlan, - pub insert_location: Option, } #[derive(Debug, Error)] pub enum ExportError { - #[error("selected monitor has no readable EDID")] - MissingEdid, - #[error("failed to patch EDID: {0}")] - Edid(#[from] EdidError), #[error("failed to write {path}: {source}")] Write { path: PathBuf, source: io::Error }, } -pub fn export_patched_edid( - monitor: &Monitor, - timing: &TimingDescriptor, - output_dir: &Path, -) -> Result { - let edid = monitor.edid.as_ref().ok_or(ExportError::MissingEdid)?; - let (mut patched, insert_location) = insert_detailed_timing(&edid.raw, timing)?; - crate::edid::clear_detailed_timing_stereo(&mut patched); - let file_name = custom_edid_file_name(&monitor.connector); - let path = output_dir.join(&file_name); - let instructions_path = output_dir.join(instructions_file_name(&monitor.connector)); - let plan = build_export_plan_for_monitor(monitor, file_name, timing.clone()); - - fs::write(&path, patched).map_err(|source| ExportError::Write { - path: path.clone(), - source, - })?; - write_instructions(&instructions_path, &path, &plan)?; - - Ok(ExportResult { - path, - instructions_path, - plan, - insert_location: Some(insert_location), - }) -} - pub fn export_workspace_edid( monitor: &Monitor, workspace: &EdidWorkspace, @@ -91,7 +41,6 @@ pub fn export_workspace_edid( path, instructions_path, plan, - insert_location: None, }) } @@ -133,23 +82,6 @@ pub fn custom_edid_file_name(connector: &str) -> String { format!("drmcru_custom_{}.bin", file_safe_connector(connector)) } -fn build_export_plan_for_monitor( - monitor: &Monitor, - edid_file_name: impl Into, - timing: TimingDescriptor, -) -> ExportPlan { - let mut plan = build_export_plan_with_file(&monitor.connector, edid_file_name, timing); - plan.position = monitor_position(monitor); - plan.scale = monitor_scale(monitor); - plan.hyprland_rule = hyprland_config::format_monitor_rule( - &plan.connector, - &plan.hyprland_mode, - &plan.position, - &plan.scale, - ); - plan -} - fn build_export_plan_for_monitor_mode( monitor: &Monitor, edid_file_name: impl Into, @@ -238,7 +170,24 @@ fn write_instructions( #[cfg(test)] mod tests { use super::*; - use crate::models::{ConnectorStatus, HyprlandMonitor}; + use crate::models::{ConnectorStatus, HyprlandMonitor, TimingDescriptor}; + + fn build_export_plan_with_file( + connector: impl Into, + edid_file_name: impl Into, + timing: TimingDescriptor, + ) -> ExportPlan { + let connector = connector.into(); + let hyprland_mode = timing.hyprland_mode(); + ExportPlan { + hyprland_rule: format!("monitor={connector},{hyprland_mode},auto,1"), + connector, + edid_file_name: edid_file_name.into(), + hyprland_mode, + position: "auto".to_string(), + scale: "1".to_string(), + } + } fn sample_timing() -> TimingDescriptor { TimingDescriptor { @@ -272,7 +221,7 @@ mod tests { } #[test] - fn both_export_paths_clear_existing_stereo_flags() { + fn workspace_export_clears_stereo_without_inserting_draft_timings() { let monitor = crate::demo::monitors().unwrap().remove(0); let mut monitor = monitor; let mut raw = monitor.edid.as_ref().unwrap().raw.clone(); @@ -296,23 +245,81 @@ mod tests { .as_nanos() )); fs::create_dir(&directory).unwrap(); - let workspace = EdidWorkspace::new(raw).unwrap(); - for workspace_export in [true, false] { - let result = if workspace_export { - export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory) - } else { - export_patched_edid(&monitor, &sample_timing(), &directory) - }; - let result = result.unwrap(); - let bytes = fs::read(result.path).unwrap(); - assert_eq!(bytes[71] & 0x61, 0); - assert_eq!(bytes[154] & 0x61, 0); - assert!( - bytes - .chunks_exact(128) - .all(crate::edid::block_checksum_valid) + let workspace = EdidWorkspace::new(raw.clone()).unwrap(); + let result = + export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory).unwrap(); + let bytes = fs::read(result.path).unwrap(); + assert_eq!(bytes.len(), raw.len()); + assert_eq!(bytes[71] & 0x61, 0); + assert_eq!(bytes[154] & 0x61, 0); + for offset in 0..bytes.len() { + if ![71, 127, 154, 255].contains(&offset) { + assert_eq!(bytes[offset], raw[offset]); + } + } + assert!( + bytes + .chunks_exact(128) + .all(crate::edid::block_checksum_valid) + ); + fs::remove_dir_all(directory).unwrap(); + } + + #[test] + fn vrr_export_preserves_non_stereo_timing_flags_and_extension_bytes() { + let mut monitor = crate::demo::monitors().unwrap().remove(0); + let mut raw = monitor.edid.as_ref().unwrap().raw.clone(); + for (offset, flags) in [(71, 0x19), (89, 0x1b), (154, 0x1b), (172, 0x19)] { + raw[offset] = flags; + } + for block in raw.chunks_exact_mut(128) { + block[127] = 0u8.wrapping_sub( + block[..127] + .iter() + .fold(0u8, |sum, byte| sum.wrapping_add(*byte)), ); } + monitor.edid = Some(crate::edid::parse_edid(raw.clone()).unwrap()); + let mut workspace = EdidWorkspace::new(raw.clone()).unwrap(); + assert!(!workspace.has_changes()); + workspace + .set_vrr_range(crate::edid::VrrRange { + min_hz: 40, + max_hz: 144, + }) + .unwrap(); + assert!( + workspace + .diff_summary() + .iter() + .all(|line| !line.contains("stereo")) + ); + let directory = std::env::temp_dir().join(format!( + "drmcru-vrr-export-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos() + )); + fs::create_dir(&directory).unwrap(); + let result = + export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory).unwrap(); + let exported = fs::read(result.path).unwrap(); + let mut expected = raw; + expected[95] = 40; + expected[127] = 0u8.wrapping_sub( + expected[..127] + .iter() + .fold(0u8, |sum, byte| sum.wrapping_add(*byte)), + ); + + assert_eq!(exported, expected); + assert!( + exported + .chunks_exact(128) + .all(crate::edid::block_checksum_valid) + ); fs::remove_dir_all(directory).unwrap(); } @@ -349,8 +356,11 @@ mod tests { edid: None, }; - let plan = - build_export_plan_for_monitor(&monitor, "drmcru_custom_DP-1.bin", sample_timing()); + let plan = build_export_plan_for_monitor_mode( + &monitor, + "drmcru_custom_DP-1.bin", + &sample_timing().hyprland_mode(), + ); let rule = plan.hyprland_monitor_rule(); if rule.starts_with("monitor=") { diff --git a/src/tui/actions.rs b/src/tui/actions.rs index d2fb808..d96da61 100644 --- a/src/tui/actions.rs +++ b/src/tui/actions.rs @@ -7,7 +7,7 @@ use super::{ App, ExtensionRow, FocusArea, ModeKey, ModeProvenance, PendingSystemAction, SystemExecution, }; use crate::edid::DtdLocation; -use crate::export::{custom_edid_file_name, export_patched_edid, export_workspace_edid}; +use crate::export::{custom_edid_file_name, export_workspace_edid}; use crate::hyprland::{self, ModeRequest}; use crate::hyprland_config::{self, MonitorRuleInspection}; use crate::install::{self, InstallPlan, InstallPreview, UninstallPlan, UninstallPreview}; @@ -971,7 +971,22 @@ impl App { } pub(super) fn export_selected_monitor(&mut self) { - let issues = self.export_validation_issues(); + if self.selected_monitor().is_none() { + self.status = "No monitor selected.".to_string(); + return; + } + let Some(workspace) = self.selected_workspace() else { + self.status = "Selected monitor has no readable EDID to export.".to_string(); + return; + }; + if !workspace.has_changes() { + self.status = + "No workspace changes are pending. Add, edit, delete, or import a timing first." + .to_string(); + return; + } + + let issues = self.workspace_validation_issues(workspace); let blocking = issues .iter() .filter(|issue| issue.starts_with("Error:")) @@ -1021,18 +1036,21 @@ impl App { return; }; - let result = match self.selected_workspace() { - Some(workspace) if workspace.has_changes() => { - let Some(mode) = self.workspace_target_mode() else { - self.status = - "Export needs at least one resolution to generate a Hyprland rule." - .to_string(); - return; - }; - export_workspace_edid(monitor, workspace, &mode, &output_dir) - } - _ => export_patched_edid(monitor, &self.draft_timing, &output_dir), + let Some(workspace) = self + .selected_workspace() + .filter(|workspace| workspace.has_changes()) + else { + self.status = + "No workspace changes are pending. Add, edit, delete, or import a timing first." + .to_string(); + return; + }; + let Some(mode) = self.workspace_target_mode() else { + self.status = + "Export needs at least one resolution to generate a Hyprland rule.".to_string(); + return; }; + let result = export_workspace_edid(monitor, workspace, &mode, &output_dir); match result { Ok(result) => { @@ -1054,67 +1072,6 @@ impl App { } } - fn export_validation_issues(&self) -> Vec { - let mut issues = Vec::new(); - let Some(monitor) = self.selected_monitor() else { - issues.push("Error: No monitor is selected.".to_string()); - return issues; - }; - - let exporting_workspace = self - .selected_workspace() - .map(EdidWorkspace::has_changes) - .unwrap_or(false); - - if exporting_workspace { - if let Some(workspace) = self.selected_workspace() { - issues.extend(self.workspace_validation_issues(workspace)); - } - } else { - let Some(edid) = monitor.edid.as_ref() else { - issues.push("Error: Selected monitor has no readable EDID to patch.".to_string()); - return issues; - }; - - if let Ok(mut workspace) = EdidWorkspace::from_edid(edid) { - issues.extend(self.workspace_validation_issues(&workspace)); - if let Err(error) = workspace.add_dtd(self.draft_timing.clone()) { - issues.push(format!("Error: Cannot insert draft timing: {error}")); - } - } - issues.push( - "Warning: No workspace EDID changes are pending; export will insert the current draft detailed timing." - .to_string(), - ); - } - - if !exporting_workspace { - issues.extend( - validate_timing(&self.draft_timing) - .into_iter() - .map(|warning| { - format!("{}: Draft timing: {}", warning.label(), warning.message) - }), - ); - if let Some(warning) = self.internal_panel_timing_warning() { - issues.push(format!("Warning: Internal panel: {}", warning.message)); - } - - if let Some(key) = ModeKey::from_timing(&self.draft_timing) { - let provenance = self.mode_provenance(key); - if provenance.sources.len() > 1 { - issues.push(format!( - "Warning: Draft timing duplicates an existing mode in {} source(s): {}.", - provenance.sources.len(), - provenance.sources.join(", ") - )); - } - } - } - - issues - } - fn workspace_validation_issues(&self, workspace: &EdidWorkspace) -> Vec { let mut issues = workspace .validate() diff --git a/src/tui/mod.rs b/src/tui/mod.rs index 8113004..c561fb4 100644 --- a/src/tui/mod.rs +++ b/src/tui/mod.rs @@ -831,7 +831,7 @@ mod tests { } #[test] - fn draft_export_checks_unknown_extension_checksums_and_length() { + fn workspace_export_checks_unknown_extension_checksums_and_length() { for truncate in [false, true] { let mut monitor = monitor_with_cta_dtd(); let mut raw = monitor.edid.take().unwrap().raw; @@ -844,6 +844,10 @@ mod tests { } monitor.edid = Some(parse_edid(raw).unwrap()); let mut app = App::new(vec![monitor]); + app.selected_workspace_mut() + .unwrap() + .add_dtd(timing()) + .unwrap(); app.export_selected_monitor(); assert!( app.details_dialog @@ -855,7 +859,7 @@ mod tests { } #[test] - fn draft_export_can_append_a_cta_when_existing_slots_are_full() { + fn adding_a_timing_explicitly_can_append_a_cta_when_existing_slots_are_full() { let mut monitor = monitor_with_cta_dtd(); let mut raw = monitor.edid.take().unwrap().raw; for slot in 0..4 { @@ -875,9 +879,70 @@ mod tests { } monitor.edid = Some(parse_edid(raw).unwrap()); let mut app = App::new(vec![monitor]); + app.open_detailed_editor(state::EditorMode::Add); + app.apply_detailed_editor(); + + assert!(app.detailed_editor.is_none()); + let workspace = app.selected_workspace().unwrap(); + assert!(workspace.has_changes()); + assert_eq!(workspace.parsed().raw.len(), 384); + assert!(workspace.validate().is_empty()); + } + + #[test] + fn export_without_a_monitor_or_edid_has_an_actionable_error() { + let mut app = App::new(Vec::new()); + app.export_selected_monitor(); + assert_eq!(app.status, "No monitor selected."); + + let mut monitor = monitor_with_cta_dtd(); + monitor.edid = None; + let mut app = App::new(vec![monitor]); + app.export_selected_monitor(); + assert_eq!( + app.status, + "Selected monitor has no readable EDID to export." + ); + assert!(app.export_confirm_dialog.is_none()); + assert!(app.export_dialog.is_none()); + } + + #[test] + fn export_refuses_unchanged_non_stereo_workspace() { + for flags in [0x1a, 0x19, 0x1b] { + let mut monitor = monitor_with_cta_dtd(); + let mut raw = monitor.edid.take().unwrap().raw; + raw[151] = flags; + repair_checksum(&mut raw[128..]); + monitor.edid = Some(parse_edid(raw.clone()).unwrap()); + let mut app = App::new(vec![monitor]); + + app.export_selected_monitor(); + + assert!(app.export_confirm_dialog.is_none()); + assert!(app.export_dialog.is_none()); + assert!(app.details_dialog.is_none()); + assert!(app.status.contains("No workspace changes")); + assert_eq!(app.selected_workspace().unwrap().export_bytes(), raw); + } + } + + #[test] + fn stereo_only_export_uses_workspace_validation_instead_of_the_draft() { + let mut monitor = monitor_with_cta_dtd(); + let mut raw = monitor.edid.take().unwrap().raw; + raw[151] |= 0xe1; + repair_checksum(&mut raw[128..]); + monitor.edid = Some(parse_edid(raw.clone()).unwrap()); + let mut app = App::new(vec![monitor]); + app.draft_timing.pixel_clock_khz = 0; + app.export_selected_monitor(); + + assert!(app.selected_workspace().unwrap().has_changes()); assert!(app.export_confirm_dialog.is_some()); assert!(app.details_dialog.is_none()); + assert_eq!(app.selected_workspace().unwrap().parsed().raw, raw); } #[test] @@ -986,9 +1051,14 @@ mod tests { } #[test] - fn export_validation_errors_cannot_be_bypassed() { + fn workspace_export_validation_errors_cannot_be_bypassed() { let mut app = App::new(vec![monitor_with_cta_dtd()]); - app.draft_timing.pixel_clock_khz = 0; + let mut invalid_timing = timing(); + invalid_timing.h_blanking = 16; + app.selected_workspace_mut() + .unwrap() + .add_dtd(invalid_timing) + .unwrap(); app.export_selected_monitor(); diff --git a/src/tui/state.rs b/src/tui/state.rs index 2fc14b2..9f5a453 100644 --- a/src/tui/state.rs +++ b/src/tui/state.rs @@ -4,7 +4,6 @@ use crate::export::ExportResult; use crate::models::{StandardTiming, StandardTimingAspect, TimingDescriptor}; use crate::timings::{CvtRequest, TimingPreset, timing_for_preset}; use crate::validation::validate_timing; -use crate::workspace::format_location; use ratatui::prelude::*; #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -179,10 +178,7 @@ impl ExportDialog { Self { path: result.path.display().to_string(), instructions_path: result.instructions_path.display().to_string(), - location: result - .insert_location - .map(format_location) - .unwrap_or_else(|| "workspace EDID".to_string()), + location: "workspace EDID".to_string(), kernel_parameter: result.plan.drm_kernel_parameter(), hyprland_rule: result.plan.hyprland_monitor_rule(), } diff --git a/src/workspace.rs b/src/workspace.rs index 4ae2739..9ccc94d 100644 --- a/src/workspace.rs +++ b/src/workspace.rs @@ -542,6 +542,21 @@ mod tests { ); } + #[test] + fn non_stereo_bit_zero_is_not_a_pending_override() { + for flags in [0x19, 0x1b] { + let mut raw = + patch_base_detailed_timing(&minimal_base_edid(0), 0, &sample_timing()).unwrap(); + raw[71] = flags; + repair_checksum(&mut raw); + let workspace = EdidWorkspace::new(raw.clone()).unwrap(); + + assert!(!workspace.has_changes()); + assert_eq!(workspace.export_bytes(), raw); + assert_eq!(workspace.diff_summary(), vec!["No EDID byte changes."]); + } + } + #[test] fn range_changes_export_with_a_valid_checksum_and_can_be_reset() { let mut raw = minimal_base_edid(0);