//! Explicit WebRCS layer writes, plus separately opted-in advanced input edits. No routing or TAKE. use crate::{ Layout, device::{self, Snapshot}, }; use serde_json::{Value, json}; use std::{ collections::BTreeSet, net::{IpAddr, SocketAddr, TcpStream}, time::Duration, }; #[derive(Clone, Copy, Debug, Default, PartialEq)] pub enum Target { #[default] Preview, Program, } #[derive(Clone, Copy, Debug, Default, PartialEq)] pub enum Sizing { #[default] OutputBox, SourceAspect, } #[derive(Clone, Debug)] pub struct Change { pub path: Vec, pub before: Value, pub after: Value, } #[derive(Clone, Debug)] pub struct Plan { pub screen: String, pub bank: String, pub target: Target, pub changes: Vec, } fn field<'a>(raw: &'a Value, path: &str) -> Result<&'a Value, String> { raw.pointer(path) .ok_or_else(|| format!("Missing device field {path}. Refresh the connection.")) } fn integer(v: f64, min: f64, max: f64, name: &str) -> Result { let v = v.round(); if !v.is_finite() || v < min || v > max { return Err(format!("{name} is outside the device range {min}–{max}.")); } Ok(v as i64) } impl Plan { /// Map stable editor IDs to device live-layer IDs, in one reviewed screen/bank. pub fn prepare( snapshot: &Snapshot, layout: &Layout, screen_index: usize, mappings: &[(usize, String)], target: Target, sizing: Sizing, ) -> Result { let screen = snapshot .screens .get(screen_index) .ok_or("Choose a device screen.")?; if mappings.is_empty() { return Err("Choose editor layers and their Midra destinations.".into()); } if screen.resolution != layout.formats().output { return Err("Match the editor and device screen resolutions before sending.".into()); } let bank = match target { Target::Preview => screen.preview_bank.as_str(), Target::Program => { if screen.preview_bank == "UP" { "DOWN" } else { "UP" } } }; let base = format!("/device/screenList/items/{}", screen.id); let mut plan = Self { screen: screen.id.clone(), bank: bank.into(), target, changes: vec![], }; let mut locals = BTreeSet::new(); let mut destinations = BTreeSet::new(); for (id, destination) in mappings { if !locals.insert(*id) || !destinations.insert(destination.clone()) { return Err("Map each editor layer to a different Midra layer.".into()); } if !screen.layers.iter().any(|l| l.id == *destination) { return Err("Choose a Midra destination for every editor layer.".into()); } let i = (0..layout.layers().len()) .find(|&i| layout.layer_info(i).id == *id) .ok_or("An editor layer was removed.")?; let g = layout.layers()[i].validate()?; let source = &layout.formats().sources[layout.formats().source_for[i]]; source.input()?; layout.formats().mapping(i, g)?; let advanced = layout.formats().advanced[i]; let input = source.input_crop; let crop = [ input.left + advanced.left, input.right + advanced.right, input.top + advanced.top, input.bottom + advanced.bottom, ]; let native = source.native.map(f64::from); let layer = format!("{base}/presetList/items/{bank}/liveLayerList/items/{destination}"); let device_layer = field(&snapshot.raw, &layer)?; let content = [ device_layer .pointer("/status/pp/contentWidth") .and_then(Value::as_f64), device_layer .pointer("/status/pp/contentHeight") .and_then(Value::as_f64), ]; if crate::device::has_content_size(device_layer) && content != [Some(native[0]), Some(native[1])] { return Err(format!( "Layer {destination}: editor native source {} × {} differs from device content {} × {}. Match source resolution before sending.", native[0], native[1], content[0].unwrap_or(0.0), content[1].unwrap_or(0.0) )); } for edge in ["left", "right", "top", "bottom"] { if field(&snapshot.raw, &format!("{layer}/mask/pp/{edge}"))?.as_i64() != Some(0) { return Err(format!( "Layer {destination} has a mask. Clear it in WebRCS before sending this crop-based layout." )); } } let quantized: Vec<_> = crop .iter() .enumerate() .map(|(j, v)| integer(v / native[j / 2] * 65535.0, 0.0, 65535.0, "Crop")) .collect::>()?; if quantized[0] + quantized[1] >= 65535 || quantized[2] + quantized[3] >= 65535 { return Err("Crop quantization removes all content.".into()); } let size = match sizing { Sizing::OutputBox => [g.width, g.height], Sizing::SourceAspect => { let scale = (g.width / native[0]).max(g.height / native[1]); [native[0] * scale, native[1] * scale] } }; let size = [ integer(size[0], 1.0, 65535.0, "Width")?, integer(size[1], 1.0, 65535.0, "Height")?, ]; let retained = [ native[0] * (1.0 - (quantized[0] + quantized[1]) as f64 / 65535.0), native[1] * (1.0 - (quantized[2] + quantized[3]) as f64 / 65535.0), ]; let scale = (size[0] as f64 / retained[0]).min(size[1] as f64 / retained[1]); if (retained[0] * scale - g.width).abs() > 1.0 || (retained[1] * scale - g.height).abs() > 1.0 { return Err("Rounded device crop/size differs from the requested visible box by more than one pixel. Adjust the box or zoom.".into()); } let center = g.center(); let mut requested = vec![ ("size/pp/sizeH", json!(size[0])), ("size/pp/sizeV", json!(size[1])), ( "position/pp/posH", json!(integer(center[0], -67268.0, 67268.0, "Center X")?), ), ( "position/pp/posV", json!(integer(center[1], -67268.0, 67268.0, "Center Y")?), ), ]; for (j, path) in [ "crop/pp/left", "crop/pp/right", "crop/pp/top", "crop/pp/bottom", ] .iter() .enumerate() { requested.push((path, json!(quantized[j]))); } requested.push(("crop/pp/aspectOverride", json!("CENTERED"))); for (suffix, after) in requested { let path = format!("{layer}/{suffix}"); let before = field(&snapshot.raw, &path)?.clone(); if before != after { plan.changes.push(Change { path: path .trim_start_matches('/') .split('/') .map(str::to_owned) .collect(), before, after, }); } } } // Release crop first so moving a heavily cropped region never temporarily // exhausts an axis while its opposite edge still has the old value. plan.changes.sort_by_key(|change| { !(change.path.get(10).is_some_and(|field| field == "crop") && change .after .as_i64() .zip(change.before.as_i64()) .is_some_and(|(after, before)| after < before)) }); Ok(plan) } fn verified(&self, snapshot: &Snapshot) -> bool { self.changes .iter() .all(|c| snapshot.raw.pointer(&format!("/{}", c.path.join("/"))) == Some(&c.after)) } } trait Transport { fn read(&mut self) -> Result; fn write(&mut self, change: &Change) -> Result<(), String>; fn pause(&self) {} } fn execute(plan: &Plan, transport: &mut impl Transport) -> Result { for (i, change) in plan.changes.iter().enumerate() { transport.write(change).map_err(|e| format!("Send stopped after {i}/{} confirmed socket writes. Device may be partially changed; refresh before retrying. {e}", plan.changes.len()))?; } // Input crop is staged independently of preset geometry, as in WebRCS. let input_crops: BTreeSet<_> = plan .changes .iter() .filter_map(|change| { let p = &change.path; (p.get(1).is_some_and(|v| v == "inputList") && p.get(8).is_some_and(|v| v == "cropping") && p.len() == 12) .then(|| p[..11].to_vec()) }) .collect(); for mut path in input_crops { path.push("xUpdate".into()); for value in [false, true] { transport .write(&Change { path: path.clone(), before: json!(!value), after: json!(value), }) .map_err(|e| format!("Input values sent, but applying input crop failed: {e}"))?; } } // WebRCS commits staged preset edits with a false -> true edge. // Always pulse, even if values already match the server's staging store. for value in [false, true] { let apply = Change { path: ["device", "preset", "control", "pp", "xUpdate"] .map(str::to_owned) .to_vec(), before: json!(!value), after: json!(value), }; transport .write(&apply) .map_err(|e| format!("Layer values sent, but applying preset updates failed: {e}"))?; } for _ in 0..10 { transport.pause(); let snapshot = transport.read().map_err(|e| format!("Commands sent, but readback failed; outcome uncertain. Refresh before retrying. {e}"))?; if plan.verified(&snapshot) { return Ok(snapshot); } } Err("Commands sent but readback did not match. Device may have clamped values or another controller changed them. Refresh and review; no automatic resend or rollback was performed.".into()) } struct Connection { host: String, socket: Option>, } impl Transport for Connection { fn read(&mut self) -> Result { device::fetch(&self.host) } fn write(&mut self, change: &Change) -> Result<(), String> { if self.socket.is_none() { let ip: IpAddr = self.host.parse().map_err(|_| "Invalid device IP")?; let address = SocketAddr::new(ip, 80); let stream = TcpStream::connect_timeout(&address, Duration::from_secs(5)) .map_err(|e| e.to_string())?; stream .set_read_timeout(Some(Duration::from_secs(5))) .map_err(|e| e.to_string())?; stream .set_write_timeout(Some(Duration::from_secs(5))) .map_err(|e| e.to_string())?; let (socket, _) = tungstenite::client(format!("ws://{address}/"), stream) .map_err(|e| e.to_string())?; self.socket = Some(socket); } let message = json!({"channel":"DEVICE", "data":{"path":change.path,"value":change.after}}) .to_string(); self.socket .as_mut() .unwrap() .send(tungstenite::Message::Text(message.into())) .map_err(|e| e.to_string()) } fn pause(&self) { std::thread::sleep(Duration::from_millis(200)); } } /// Explicit send: write fields, pulse preset xUpdate, then verify geometry readback. /// Banks are pinned; another controller's TAKE can change their on-air role. pub fn send(host: &str, plan: &Plan) -> Result { let mut connection = Connection { host: host.trim().into(), socket: None, }; execute(plan, &mut connection) } #[cfg(test)] mod tests { use super::*; fn snapshot() -> Snapshot { let layer = json!({"position":{"pp":{"posH":500,"posV":300}},"size":{"pp":{"sizeH":640,"sizeV":360}},"source":{"pp":{"input":"INPUT_4"}},"status":{"pp":{"contentWidth":1920,"contentHeight":1080}},"crop":{"pp":{"left":0,"right":0,"top":0,"bottom":0,"aspectOverride":"GLOBAL_SETTING"}},"mask":{"pp":{"left":0,"right":0,"top":0,"bottom":0}}}); let raw = json!({"device": {"preset":{"control":{"pp":{"xUpdate":true,"enableAutoUpdate":false}}},"transition":{"screenList":{"items":{"1":{"status":{"pp":{"transition":"AT_DOWN"}}}}}},"screenList":{"items":{"1":{"canvas":{"status":{"size":{"pp":{"sizeH":1920,"sizeV":1080}}}},"presetList":{"items":{"UP":{"liveLayerList":{"items":{"1":layer,"2":layer}}},"DOWN":{"liveLayerList":{"items":{"1":layer,"2":layer}}}}}}}}}}); Snapshot::parse( &json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}), &raw, ) .unwrap() } fn layout() -> Layout { let mut l = Layout::default(); l.select(Some(0)); l.apply( 0, crate::Geometry { x: 12.0, y: 34.0, width: 300.0, height: 250.0, }, ) .unwrap(); l.set_framing( 0, crate::formats::Framing { zoom: 2.0, offset: [30.0, 0.0], }, ) .unwrap(); l } #[test] fn unassigned_existing_layers_accept_geometry_without_routing_changes() { let identity = json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}); for input in ["NONE", ""] { for size in [json!(0), Value::Null] { let mut raw = snapshot().raw; for bank in ["UP", "DOWN"] { let layer = raw.pointer_mut(&format!("/device/screenList/items/1/presetList/items/{bank}/liveLayerList/items/1")).unwrap(); layer["source"]["pp"]["input"] = json!(input); layer["status"]["pp"]["contentWidth"] = size.clone(); layer["status"]["pp"]["contentHeight"] = size.clone(); } let state = Snapshot::parse(&identity, &raw).unwrap(); let editor = layout(); for target in [Target::Preview, Target::Program] { for sizing in [Sizing::OutputBox, Sizing::SourceAspect] { let plan = Plan::prepare(&state, &editor, 0, &[(2, "1".into())], target, sizing) .unwrap(); assert!(!plan.changes.is_empty()); assert!( plan.changes .iter() .all(|c| !c.path.iter().any(|key| key == "source")) ); assert!( Plan::prepare(&state, &editor, 0, &[(2, "99".into())], target, sizing) .is_err() ); } } } } } #[test] fn both_strategies_include_crop_aspect_size_and_center_only() { let s = snapshot(); let l = layout(); for (strategy, expected_width) in [(Sizing::OutputBox, 300), (Sizing::SourceAspect, 444)] { let plan = Plan::prepare(&s, &l, 0, &[(2, "1".into())], Target::Preview, strategy).unwrap(); assert_eq!(plan.bank, "UP"); assert!( plan.changes .iter() .any(|c| c.path.last().unwrap() == "sizeH" && c.after == json!(expected_width)) ); assert!( plan.changes .iter() .any(|c| c.path.last().unwrap() == "posH" && c.after == json!(162)) ); for c in plan.changes { assert!(matches!(c.path[10].as_str(), "size" | "position" | "crop")); assert_eq!(c.path[5], "items"); } } let program = Plan::prepare( &s, &l, 0, &[(2, "1".into())], Target::Program, Sizing::OutputBox, ) .unwrap(); assert_eq!(program.bank, "DOWN"); assert!( Plan::prepare( &s, &l, 0, &[(1, "1".into()), (2, "1".into())], Target::Preview, Sizing::OutputBox ) .is_err() ); } struct Mock { state: Snapshot, writes: usize, fail_at: Option, ignore: bool, writes_log: Vec<(Vec, Value)>, } impl Transport for Mock { fn read(&mut self) -> Result { Ok(self.state.clone()) } fn write(&mut self, c: &Change) -> Result<(), String> { if self.fail_at == Some(self.writes) { return Err("Connection lost".into()); } self.writes += 1; self.writes_log.push((c.path.clone(), c.after.clone())); if !self.ignore { *self .state .raw .pointer_mut(&format!("/{}", c.path.join("/"))) .unwrap() = c.after.clone(); } Ok(()) } } #[test] fn explicit_input_crop_changes_pulse_only_that_input_before_preset_apply() { let mut state = snapshot(); state.raw["device"]["inputList"] = json!({"items":{"INPUT_4":{"plugList":{"items":{"2":{"settings":{"cropping":{"control":{"pp":{"left":0,"xUpdate":true}}}}}}}}}}); let path = "device/inputList/items/INPUT_4/plugList/items/2/settings/cropping/control/pp/left"; let plan = Plan { screen: "1".into(), bank: "UP".into(), target: Target::Preview, changes: vec![Change { path: path.split('/').map(str::to_owned).collect(), before: json!(0), after: json!(40), }], }; let mut transport = Mock { state, writes: 0, fail_at: None, ignore: false, writes_log: vec![], }; execute(&plan, &mut transport).unwrap(); assert_eq!(transport.writes_log.len(), 5); for (i, value) in [(1, false), (2, true)] { assert_eq!( transport.writes_log[i].0.join("/"), path.replace("/left", "/xUpdate") ); assert_eq!(transport.writes_log[i].1, json!(value)); } assert_eq!( transport.writes_log[3].0.join("/"), "device/preset/control/pp/xUpdate" ); } #[test] fn crop_decreases_precede_increases_when_reframing() { let mut state = snapshot(); *state.raw.pointer_mut("/device/screenList/items/1/presetList/items/UP/liveLayerList/items/1/crop/pp/right").unwrap()=json!(50000); let plan = Plan::prepare( &state, &layout(), 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox, ) .unwrap(); let right = plan .changes .iter() .position(|c| c.path.last().unwrap() == "right") .unwrap(); let left = plan .changes .iter() .position(|c| c.path.last().unwrap() == "left") .unwrap(); assert!(right < left); } #[test] fn custom_input_combines_crop_once_and_rejects_mask_and_source_mismatch() { let mut state = snapshot(); let mut l = layout(); let mut source = l.formats().sources[0]; source.input_crop.top = 40.0; source.input_crop.bottom = 40.0; l.configure(0, 0, source, l.layers()[0], true).unwrap(); l.set_framing( 0, crate::formats::Framing { zoom: 2.0, offset: [30.0, 0.0], }, ) .unwrap(); let plan = Plan::prepare( &state, &l, 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox, ) .unwrap(); let crop = l.formats().advanced[0]; let top = plan .changes .iter() .find(|c| c.path.last().unwrap() == "top") .unwrap(); assert_eq!( top.after, json!(((40.0 + crop.top) / 1080.0 * 65535.0).round() as i64) ); let path = "/device/screenList/items/1/presetList/items/UP/liveLayerList/items/1"; *state .raw .pointer_mut(&format!("{path}/mask/pp/top")) .unwrap() = json!(1); assert!( Plan::prepare( &state, &l, 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox ) .unwrap_err() .contains("mask") ); *state .raw .pointer_mut(&format!("{path}/mask/pp/top")) .unwrap() = json!(0); *state .raw .pointer_mut(&format!("{path}/status/pp/contentWidth")) .unwrap() = json!(1280); assert!( Plan::prepare( &state, &l, 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox ) .unwrap_err() .contains("differs") ); } #[test] fn sent_centered_crop_imports_visible_box_and_framing_in_both_modes() { for sizing in [Sizing::OutputBox, Sizing::SourceAspect] { let state = snapshot(); let l = layout(); let plan = Plan::prepare(&state, &l, 0, &[(2, "1".into())], Target::Preview, sizing).unwrap(); let mut mock = Mock { state, writes: 0, fail_at: None, ignore: false, writes_log: vec![], }; let result = execute(&plan, &mut mock).unwrap(); let imported = Snapshot::parse( &json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}), &result.raw, ) .unwrap(); let layer = &imported.screens[0].layers[0]; assert!(layer.unsupported.is_none()); assert!((layer.geometry.width - 300.0).abs() < 1.0); assert!((layer.geometry.height - 250.0).abs() < 1.0); let mut restored = Layout::default(); let before = restored.layers().clone(); let formats = restored.formats().clone(); restored .import_device_layers(&[(Some(2), layer.geometry, layer.framing)]) .unwrap(); let framing = restored .formats() .mapping(0, restored.layers()[0]) .unwrap() .framing; assert!((framing.zoom - 2.0).abs() < 0.001); assert!((framing.offset[0] - 30.0).abs() < 0.01); restored.undo(); assert_eq!(*restored.layers(), before); assert_eq!(*restored.formats(), formats); } } #[test] fn changed_device_state_does_not_block_send_and_partial_failure_is_reported() { let state = snapshot(); let plan = Plan::prepare( &state, &layout(), 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox, ) .unwrap(); let mut mock = Mock { state: state.clone(), writes: 0, fail_at: None, ignore: false, writes_log: vec![], }; *mock .state .raw .pointer_mut("/device/screenList/items/1/canvas/status/size/pp") .unwrap() = json!(null); assert!(plan.verified(&execute(&plan, &mut mock).unwrap())); assert_eq!(mock.writes, plan.changes.len() + 2); mock.state = state; mock.writes = 0; mock.fail_at = Some(2); assert!( execute(&plan, &mut mock) .unwrap_err() .contains("partially changed") ); assert_eq!(mock.writes, 2); mock.writes = 0; mock.fail_at = Some(plan.changes.len()); assert!( execute(&plan, &mut mock) .unwrap_err() .contains("applying preset updates failed") ); } #[test] fn success_requires_readback_and_unchanged_values_still_apply() { let state = snapshot(); let mut plan = Plan::prepare( &state, &layout(), 0, &[(2, "1".into())], Target::Preview, Sizing::OutputBox, ) .unwrap(); let mut mock = Mock { state: state.clone(), writes: 0, fail_at: None, ignore: false, writes_log: vec![], }; assert!(plan.verified(&execute(&plan, &mut mock).unwrap())); assert_eq!(mock.writes, plan.changes.len() + 2); let pulse = ["device", "preset", "control", "pp", "xUpdate"] .map(str::to_owned) .to_vec(); assert_eq!( &mock.writes_log[plan.changes.len()..], &[(pulse.clone(), json!(false)), (pulse, json!(true))] ); assert!( mock.writes_log[..plan.changes.len()] .iter() .all(|(path, _)| path.last().unwrap() != "xUpdate") ); mock.state = state; mock.writes = 0; mock.ignore = true; assert!( execute(&plan, &mut mock) .unwrap_err() .contains("did not match") ); assert_eq!(mock.writes, plan.changes.len() + 2); plan.changes.clear(); mock.writes = 0; execute(&plan, &mut mock).unwrap(); assert_eq!(mock.writes, 2); } }