From a47e1452bdd9c97510ebc8c5f33dc1afe1bc8944 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Thu, 15 Oct 2026 23:55:29 +0200 Subject: [PATCH] feat: reflect confirmed mute state over MIDI Open and reconcile configured MIDI outputs independently, send opt-in note or CC feedback from confirmed mute observations, deduplicate successful values, and resynchronize after reconnect. Enable green mute feedback in the APC MINI example and document the profile fields and mixed/offline policy. Tests: cargo fmt --all -- --check Tests: cargo check --workspace --all-targets --all-features --locked Tests: cargo test --workspace --all-targets --all-features --locked Tests: cargo test --workspace --doc --all-features --locked Tests: cargo clippy --workspace --all-targets --all-features --locked -- -D warnings Tests: cargo build --workspace --release --all-features --locked Tests: cargo check --workspace --locked Tests: cargo check --workspace --no-default-features --locked Tests: cargo check -p midi --no-default-features --features midir --locked Tests: cargo check -p volume_lib --no-default-features --features pulse --locked --- README.md | 3 +- architecture.md | 7 + config/src/profile.rs | 29 ++- docs/configuration.md | 13 +- examples/profiles/arch-pipewire.toml | 5 + fader_master/src/local.rs | 3 +- fader_master/src/midi_runtime.rs | 310 ++++++++++++++++++++++++++- midi/src/lib.rs | 3 +- midi/src/transport.rs | 86 +++++++- task.md | 7 + 10 files changed, 452 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index fc9f10c..ad7170b 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,8 @@ same profile can switch to a compact stacked layout for narrow terminals: exact and regular-expression capture rules. - Control individual applications, non-nesting application groups, and the default output without changing live audio during discovery. -- Learn volume and mute controls from MIDI, use pickup to prevent jumps, and +- Learn volume and mute controls from MIDI, reflect confirmed mute state on + control-surface LEDs, use pickup to prevent jumps, and keep independently identified controllers from colliding. - Arrange faders and named separators directly in the mixer. Choose Slim, Standard, or Thick faders, and hide detail faders behind a group when useful. diff --git a/architecture.md b/architecture.md index 8f75bf5..895cef9 100644 --- a/architecture.md +++ b/architecture.md @@ -209,6 +209,13 @@ Keep bindings for absent surfaces. Re-enumerate ports on hotplug notifications o Output capabilities are explicit: mute LED, value display, motorized fader, or none. Non-motorized devices may still receive supported LED/display feedback; never assume every surface has LEDs. Mixed mute uses a declared mixed indicator, otherwise LED on only for all-muted and the TUI shows mixed. Send full supported state on attach and incremental changes thereafter. Device feedback failures are separate from audio operation failures. +The first implemented output slice is binding-level mute feedback. A binding +with `feedback` sends its declared note or CC `on` value only for a uniformly +confirmed muted target, sends `off` for uniformly unmuted or mixed state, and +sends nothing for an unavailable target. Successful messages are deduplicated; +an independently reconnected output invalidates that cache and receives a full +current refresh. Pending intent is never treated as confirmation. + Non-motorized absolute controls default to pickup: after startup, external changes, another surface's move, or profile switch, wait until the physical value crosses or enters a configured tolerance around the observed target before sending volume commands. First input establishes position; an out-of-range external volume uses the nearest physical endpoint. Relative encoders do not need pickup. Reset pickup on disconnect/rebind. For motors, add touch-aware inhibition before enabling motor output; unsupported touch means no claimed touch protection. Avoid feedback loops with direction/origin tracking, quantization-aware equality, rate limiting, and device-specific echo suppression. MIDI has no universal request IDs: generic time-window byte suppression can swallow real input, so only enable it for documented echoing device profiles and test it. Server observations never themselves generate audio commands. diff --git a/config/src/profile.rs b/config/src/profile.rs index 2ee9f00..5e63a2b 100644 --- a/config/src/profile.rs +++ b/config/src/profile.rs @@ -280,7 +280,7 @@ enum Edge { #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)] #[serde(deny_unknown_fields)] -struct Feedback { +pub struct Feedback { kind: MessageKind, channel: u16, number: u16, @@ -653,6 +653,33 @@ impl Binding { pub const fn number(&self) -> u16 { self.message.number } + + /// Optional outbound message used to reflect confirmed state on the surface. + pub const fn feedback(&self) -> Option<&Feedback> { + self.feedback.as_ref() + } +} + +impl Feedback { + pub const fn message_kind(&self) -> MessageKind { + self.kind + } + + pub const fn channel(&self) -> u16 { + self.channel + } + + pub const fn number(&self) -> u16 { + self.number + } + + pub const fn on(&self) -> u16 { + self.on + } + + pub const fn off(&self) -> u16 { + self.off + } } fn validate_version(version: u16) -> Result<(), ConfigError> { diff --git a/docs/configuration.md b/docs/configuration.md index 804fef6..d005e2b 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -65,7 +65,8 @@ default adopts live audio without changing it. Start from one of the tracked, validated examples: - [`arch-pipewire.toml`](../examples/profiles/arch-pipewire.toml) demonstrates - multiple applications, a group, APC MINI identity, and volume/mute bindings. + multiple applications, a group, APC MINI identity, volume/mute bindings, and + green mute-button feedback. - [`desktop.toml`](../examples/profiles/desktop.toml) is a smaller profile with MIDI output feedback. @@ -169,12 +170,22 @@ fader = "music-fader" action = "toggle_mute" edge = "press" message = { kind = "note", channel = 1, number = 64 } +feedback = { kind = "note", channel = 1, number = 64, on = 127, off = 0 } ``` The TUI can choose a controller, learn the next supported movement or button press, and remove an assignment independently for volume and mute. Unassigned actions inherit `[ui].default_controller` for learning. +`feedback` is optional and requires the binding's surface to define +`output_port`. After that output attaches, the server sends `on` when the +fader's target is uniformly and observably muted and `off` when it is unmuted +or a group has mixed mute state. Offline targets emit no guess. Only confirmed +audio observations drive feedback, so a pending or failed mute write never +lights an LED as if it succeeded. Reconnect sends the current state again; +unchanged states are deduplicated. Both note and CC feedback use 1-based +channels and values from 0–127. + ## Validation, migration, and Save Validate a file without opening MIDI/audio devices or changing live audio: diff --git a/examples/profiles/arch-pipewire.toml b/examples/profiles/arch-pipewire.toml index 6a31577..37a1d10 100644 --- a/examples/profiles/arch-pipewire.toml +++ b/examples/profiles/arch-pipewire.toml @@ -40,6 +40,7 @@ volume_mode = "absolute" id = "apc-mini" label = "APC MINI" input_port = "APC MINI:APC MINI MIDI 1" +output_port = "APC MINI:APC MINI MIDI 1" usb_vendor_id = "09e8" usb_product_id = "0028" usb_serial = "Ver00.10" @@ -100,6 +101,7 @@ fader = "music-fader" action = "toggle_mute" edge = "press" message = { kind = "note", channel = 1, number = 64 } +feedback = { kind = "note", channel = 1, number = 64, on = 1, off = 0 } [[bindings]] surface = "apc-mini" @@ -107,6 +109,7 @@ fader = "browser-fader" action = "toggle_mute" edge = "press" message = { kind = "note", channel = 1, number = 65 } +feedback = { kind = "note", channel = 1, number = 65, on = 1, off = 0 } [[bindings]] surface = "apc-mini" @@ -114,6 +117,7 @@ fader = "media-fader" action = "toggle_mute" edge = "press" message = { kind = "note", channel = 1, number = 66 } +feedback = { kind = "note", channel = 1, number = 66, on = 1, off = 0 } [[bindings]] surface = "apc-mini" @@ -121,3 +125,4 @@ fader = "master-fader" action = "toggle_mute" edge = "press" message = { kind = "note", channel = 1, number = 98 } +feedback = { kind = "note", channel = 1, number = 98, on = 1, off = 0 } diff --git a/fader_master/src/local.rs b/fader_master/src/local.rs index 5de8a17..145e8b0 100644 --- a/fader_master/src/local.rs +++ b/fader_master/src/local.rs @@ -292,7 +292,6 @@ impl LocalServer { } } } - self.mixer.set_devices(self.midi.snapshot()); self.flush_dispatch(); match self.worker.receive_timeout(self.poll_interval) { Ok(event) => { @@ -315,6 +314,8 @@ impl LocalServer { } } self.flush_dispatch(); + self.midi.sync_feedback(&self.mixer.snapshot()); + self.mixer.set_devices(self.midi.snapshot()); while let Some(mut client) = self.listener.accept()? { let _ = client.set_read_timeout(Some(SERVER_CLIENT_TIMEOUT)); let _ = client.set_write_timeout(Some(SERVER_CLIENT_TIMEOUT)); diff --git a/fader_master/src/midi_runtime.rs b/fader_master/src/midi_runtime.rs index 4c47f93..b02f288 100644 --- a/fader_master/src/midi_runtime.rs +++ b/fader_master/src/midi_runtime.rs @@ -1,5 +1,5 @@ use std::{ - collections::BTreeMap, + collections::{BTreeMap, BTreeSet}, sync::mpsc::{Receiver, SyncSender, TryRecvError, sync_channel}, time::{Duration, Instant}, }; @@ -11,11 +11,11 @@ use fader_core::{ }; use midi::{ ButtonEdge, DeviceMatch, LinuxIdentityCatalog, MidiInputCatalog, MidiInputConnection, - MidiInputEvent, MidiIntent, MidiMessage, MidiRouter, SurfaceAction, SurfaceAssignment, - SurfaceLifecycle, SurfaceStatus, + MidiInputEvent, MidiIntent, MidiMessage, MidiOutputCatalog, MidiOutputConnection, MidiRouter, + SurfaceAction, SurfaceAssignment, SurfaceLifecycle, SurfaceStatus, }; -use crate::ipc::MidiDevice; +use crate::ipc::{MidiDevice, MixerObjectKey, MixerObjectKind, MixerSnapshot}; const SCAN_INTERVAL: Duration = Duration::from_secs(1); const EVENT_CAPACITY: usize = 256; @@ -25,14 +25,135 @@ pub struct MidiRuntime { lifecycle: SurfaceLifecycle, labels: BTreeMap, connections: BTreeMap, + output_names: BTreeMap, + output_connections: BTreeMap, + output_backend_ids: BTreeMap, + output_errors: BTreeMap, sender: SyncSender, receiver: Receiver, last_scan: Option, scan_error: Option, router: MidiRouter, + feedback: FeedbackEngine, learn: Option, } +#[derive(Clone, Debug, Eq, PartialEq)] +struct FeedbackBinding { + surface: SurfaceId, + fader: FaderId, + target: MixerObjectKey, + on: [u8; 3], + off: [u8; 3], +} + +#[derive(Clone, Debug, Eq, PartialEq)] +struct FeedbackMessage { + binding: usize, + surface: SurfaceId, + bytes: [u8; 3], + muted: bool, +} + +#[derive(Debug)] +struct FeedbackEngine { + bindings: Vec, + sent: BTreeMap, +} + +impl FeedbackEngine { + fn new(profile: &Profile) -> Result { + let bindings = profile + .bindings() + .iter() + .filter_map(|binding| { + (binding.action() == fader_config::Action::ToggleMute) + .then(|| binding.feedback().map(|feedback| (binding, feedback)))? + }) + .map(|(binding, feedback)| { + let channel = + u8::try_from(feedback.channel() - 1).map_err(|error| error.to_string())?; + let status = match feedback.message_kind() { + fader_config::MessageKind::Cc => 0xb0 | channel, + fader_config::MessageKind::Note => 0x90 | channel, + }; + let number = u8::try_from(feedback.number()).map_err(|error| error.to_string())?; + let fader = profile + .faders() + .iter() + .find(|fader| fader.id() == binding.fader()) + .ok_or_else(|| { + format!("feedback references unknown fader {:?}", binding.fader()) + })?; + Ok(FeedbackBinding { + surface: SurfaceId::new(binding.surface()) + .map_err(|error| error.to_string())?, + fader: FaderId::new(binding.fader()).map_err(|error| error.to_string())?, + target: MixerObjectKey { + kind: match fader.target_kind() { + fader_config::TargetKind::Application => MixerObjectKind::Application, + fader_config::TargetKind::Group => MixerObjectKind::Group, + fader_config::TargetKind::Output => MixerObjectKind::Output, + }, + id: fader.target_id().to_owned(), + }, + on: [ + status, + number, + u8::try_from(feedback.on()).map_err(|error| error.to_string())?, + ], + off: [ + status, + number, + u8::try_from(feedback.off()).map_err(|error| error.to_string())?, + ], + }) + }) + .collect::, String>>()?; + Ok(Self { + bindings, + sent: BTreeMap::new(), + }) + } + + fn plan( + &self, + confirmed: &BTreeMap, + attached: &BTreeSet, + ) -> Vec { + self.bindings + .iter() + .enumerate() + .filter_map(|(index, binding)| { + let muted = *confirmed.get(&binding.fader)?; + if !attached.contains(&binding.surface) + || self.sent.get(&index).is_some_and(|sent| *sent == muted) + { + return None; + } + Some(FeedbackMessage { + binding: index, + surface: binding.surface.clone(), + bytes: if muted { binding.on } else { binding.off }, + muted, + }) + }) + .collect() + } + + fn record_sent(&mut self, message: &FeedbackMessage) { + self.sent.insert(message.binding, message.muted); + } + + fn invalidate_surface(&mut self, surface: &SurfaceId) { + for (index, binding) in self.bindings.iter().enumerate() { + if &binding.surface == surface { + self.sent.remove(&index); + } + } + } +} + #[derive(Clone, Debug, Eq, PartialEq)] pub struct MidiLearn { pub surface: SurfaceId, @@ -62,6 +183,7 @@ impl std::fmt::Debug for MidiRuntime { .debug_struct("MidiRuntime") .field("surfaces", &self.labels.len()) .field("connections", &self.connections.len()) + .field("output_connections", &self.output_connections.len()) .field("scan_error", &self.scan_error) .finish() } @@ -70,12 +192,16 @@ impl std::fmt::Debug for MidiRuntime { impl MidiRuntime { pub fn new(profile: &Profile) -> Result { let mut labels = BTreeMap::new(); + let mut output_names = BTreeMap::new(); let assignments = profile .surfaces() .iter() .map(|surface| { let id = SurfaceId::new(surface.id()).map_err(|error| error.to_string())?; labels.insert(id.clone(), surface.label().to_owned()); + if let Some(output) = surface.output_port() { + output_names.insert(id.clone(), output.to_owned()); + } Ok(SurfaceAssignment { surface: id, expected: DeviceMatch { @@ -118,16 +244,22 @@ impl MidiRuntime { }) .collect::, String>>()?; let router = MidiRouter::new(Bindings::new(bindings).map_err(|error| error.to_string())?); + let feedback = FeedbackEngine::new(profile)?; let (sender, receiver) = sync_channel(EVENT_CAPACITY); Ok(Self { lifecycle, labels, connections: BTreeMap::new(), + output_names, + output_connections: BTreeMap::new(), + output_backend_ids: BTreeMap::new(), + output_errors: BTreeMap::new(), sender, receiver, last_scan: None, scan_error: None, router, + feedback, learn: None, }) } @@ -258,15 +390,22 @@ impl MidiRuntime { .unwrap_or_else(|| id.as_str().to_owned()), status: name.to_owned(), backend_id, - error: status_error.or_else(|| self.scan_error.clone()), + error: status_error + .or_else(|| self.output_errors.get(id).cloned()) + .or_else(|| self.scan_error.clone()), } }) .collect() } fn scan(&mut self) { - let result = self.discover_and_reconcile(); - self.scan_error = result.err(); + let input_error = self.discover_and_reconcile().err(); + if let Err(error) = self.discover_and_reconcile_outputs() { + for surface in self.output_names.keys() { + self.output_errors.insert(surface.clone(), error.clone()); + } + } + self.scan_error = input_error; } fn discover_and_reconcile(&mut self) -> Result<(), String> { @@ -322,10 +461,138 @@ impl MidiRuntime { } } } + + fn discover_and_reconcile_outputs(&mut self) -> Result<(), String> { + if self.output_names.is_empty() { + return Ok(()); + } + let catalog = MidiOutputCatalog::new("fader_master output discovery") + .map_err(|error| error.to_string())?; + let ports = catalog.ports().map_err(|error| error.to_string())?; + let configured: Vec<_> = self + .output_names + .iter() + .map(|(surface, name)| (surface.clone(), name.clone())) + .collect(); + for (surface, expected_name) in configured { + let matches: Vec<_> = ports + .iter() + .filter(|port| stable_port_name(port.name()) == stable_port_name(&expected_name)) + .collect(); + match matches.as_slice() { + [port] => { + if self.output_backend_ids.get(&surface).map(String::as_str) != Some(port.id()) + { + self.disconnect_output(&surface); + self.connect_output(surface, port.id()); + } + } + [] => { + self.disconnect_output(&surface); + self.output_errors + .insert(surface, format!("MIDI output {expected_name:?} is missing")); + } + _ => { + self.disconnect_output(&surface); + self.output_errors.insert( + surface, + format!("MIDI output {expected_name:?} is ambiguous"), + ); + } + } + } + Ok(()) + } + + fn connect_output(&mut self, surface: SurfaceId, backend_id: &str) { + let result = (|| { + let catalog = MidiOutputCatalog::new("fader_master output")?; + let ports = catalog.ports()?; + let port = ports + .iter() + .find(|port| port.id() == backend_id) + .ok_or_else(|| { + midi::MidiTransportError::OutputConnect("port disappeared".to_owned()) + })?; + catalog.connect(port, &format!("fader_master {} output", surface.as_str())) + })(); + match result { + Ok(connection) => { + self.output_connections.insert(surface.clone(), connection); + self.output_backend_ids + .insert(surface.clone(), backend_id.to_owned()); + self.output_errors.remove(&surface); + self.feedback.invalidate_surface(&surface); + } + Err(error) => { + self.output_errors.insert(surface, error.to_string()); + } + } + } + + fn disconnect_output(&mut self, surface: &SurfaceId) { + if self.output_connections.remove(surface).is_some() { + self.feedback.invalidate_surface(surface); + } + self.output_backend_ids.remove(surface); + } + + pub fn sync_feedback(&mut self, snapshot: &MixerSnapshot) { + let confirmed = self + .feedback + .bindings + .iter() + .filter_map(|binding| { + let object = snapshot + .objects + .iter() + .find(|object| object.object == binding.target)?; + object + .muted + .or(object.mute_mixed.then_some(false)) + .map(|muted| (binding.fader.clone(), muted)) + }) + .collect(); + let attached = self.output_connections.keys().cloned().collect(); + for message in self.feedback.plan(&confirmed, &attached) { + let Some(connection) = self.output_connections.get_mut(&message.surface) else { + continue; + }; + let result = connection.send(&message.bytes); + match result { + Ok(()) => self.feedback.record_sent(&message), + Err(error) => { + self.output_errors + .insert(message.surface.clone(), error.to_string()); + self.disconnect_output(&message.surface); + } + } + } + } +} + +fn stable_port_name(name: &str) -> &str { + let Some((prefix, suffix)) = name.rsplit_once(' ') else { + return name; + }; + let Some((client, port)) = suffix.split_once(':') else { + return name; + }; + if !client.is_empty() + && !port.is_empty() + && client.bytes().all(|byte| byte.is_ascii_digit()) + && port.bytes().all(|byte| byte.is_ascii_digit()) + { + prefix + } else { + name + } } #[cfg(test)] mod tests { + use std::collections::{BTreeMap, BTreeSet}; + use super::*; use fader_core::{MidiChannel, MidiData}; use midi::{ButtonEdge, MidiMessage}; @@ -460,4 +727,33 @@ mod tests { [MidiIntent::AbsoluteVolume { fader, .. }] if fader.as_str() == "music-fader" )); } + + #[test] + fn confirmed_mute_feedback_is_surface_scoped_deduplicated_and_resynced() { + let profile = Profile::parse(include_str!("../../examples/profiles/desktop.toml")).unwrap(); + let mut feedback = FeedbackEngine::new(&profile).unwrap(); + let surface = SurfaceId::new("desk-left").unwrap(); + let fader = FaderId::new("media-fader").unwrap(); + let attached = BTreeSet::from([surface.clone()]); + + assert!(feedback.plan(&BTreeMap::new(), &attached).is_empty()); + + let muted = BTreeMap::from([(fader.clone(), true)]); + let messages = feedback.plan(&muted, &attached); + assert_eq!(messages.len(), 1); + assert_eq!(messages[0].surface, surface); + assert_eq!(messages[0].bytes, [0x90, 32, 127]); + feedback.record_sent(&messages[0]); + assert!(feedback.plan(&muted, &attached).is_empty()); + + let unmuted = BTreeMap::from([(fader, false)]); + let messages = feedback.plan(&unmuted, &attached); + assert_eq!(messages.len(), 1); + assert_eq!(messages[0].bytes, [0x90, 32, 0]); + feedback.record_sent(&messages[0]); + + feedback.invalidate_surface(&surface); + assert_eq!(feedback.plan(&unmuted, &attached).len(), 1); + assert!(feedback.plan(&unmuted, &BTreeSet::new()).is_empty()); + } } diff --git a/midi/src/lib.rs b/midi/src/lib.rs index 5809b30..4740568 100644 --- a/midi/src/lib.rs +++ b/midi/src/lib.rs @@ -23,5 +23,6 @@ pub use linux_identity::{LinuxIdentityCatalog, LinuxIdentityError}; pub use router::{MidiIntent, MidiRouter}; #[cfg(feature = "midir")] pub use transport::{ - InputPort, MidiInputCatalog, MidiInputConnection, MidiInputEvent, MidiTransportError, + InputPort, MidiInputCatalog, MidiInputConnection, MidiInputEvent, MidiOutputCatalog, + MidiOutputConnection, MidiTransportError, OutputPort, }; diff --git a/midi/src/transport.rs b/midi/src/transport.rs index a48a31c..5fb0a5f 100644 --- a/midi/src/transport.rs +++ b/midi/src/transport.rs @@ -5,7 +5,10 @@ use std::sync::{ }; use fader_core::SurfaceId; -use midir::{Ignore, MidiInput, MidiInputConnection as NativeConnection, MidiInputPort}; +use midir::{ + Ignore, MidiInput, MidiInputConnection as NativeInputConnection, MidiInputPort, MidiOutput, + MidiOutputConnection as NativeOutputConnection, MidiOutputPort, +}; use thiserror::Error; use crate::{DecodeError, MidiMessage, decode_message}; @@ -63,6 +66,14 @@ pub enum MidiTransportError { PortInfo(String), #[error("could not connect MIDI input: {0}")] Connect(String), + #[error("could not initialize MIDI output: {0}")] + OutputInitialize(String), + #[error("could not read MIDI output port information: {0}")] + OutputPortInfo(String), + #[error("could not connect MIDI output: {0}")] + OutputConnect(String), + #[error("could not send MIDI output: {0}")] + OutputSend(String), } /// One-use midir catalog; connecting consumes it because midir transfers input ownership. @@ -154,10 +165,81 @@ fn enqueue_bytes( /// Keeps a midir input open and exposes callback overflow as an explicit fault. pub struct MidiInputConnection { - _connection: NativeConnection<()>, + _connection: NativeInputConnection<()>, overflowed: Arc, } +/// One MIDI output port reported by midir. +pub struct OutputPort { + id: String, + name: String, + native: MidiOutputPort, +} + +impl OutputPort { + #[must_use] + pub fn id(&self) -> &str { + &self.id + } + + #[must_use] + pub fn name(&self) -> &str { + &self.name + } +} + +/// One-use midir output catalog. +pub struct MidiOutputCatalog { + output: MidiOutput, +} + +impl MidiOutputCatalog { + pub fn new(client_name: &str) -> Result { + MidiOutput::new(client_name) + .map(|output| Self { output }) + .map_err(|error| MidiTransportError::OutputInitialize(error.to_string())) + } + + pub fn ports(&self) -> Result, MidiTransportError> { + self.output + .ports() + .into_iter() + .map(|native| { + let id = native.id(); + let name = self + .output + .port_name(&native) + .map_err(|error| MidiTransportError::OutputPortInfo(error.to_string()))?; + Ok(OutputPort { id, name, native }) + }) + .collect() + } + + pub fn connect( + self, + port: &OutputPort, + connection_name: &str, + ) -> Result { + self.output + .connect(&port.native, connection_name) + .map(|connection| MidiOutputConnection { connection }) + .map_err(|error| MidiTransportError::OutputConnect(error.to_string())) + } +} + +/// Keeps a native MIDI output open for synchronous, short-message writes. +pub struct MidiOutputConnection { + connection: NativeOutputConnection, +} + +impl MidiOutputConnection { + pub fn send(&mut self, message: &[u8]) -> Result<(), MidiTransportError> { + self.connection + .send(message) + .map_err(|error| MidiTransportError::OutputSend(error.to_string())) + } +} + impl MidiInputConnection { #[must_use] pub fn overflowed(&self) -> bool { diff --git a/task.md b/task.md index 32d89f0..159f518 100644 --- a/task.md +++ b/task.md @@ -218,6 +218,13 @@ and no-default-feature checks/tests pass. Dependencies: M4, M5. +- [x] **M6.0 Confirmed mute lights:** opt-in note/CC feedback follows confirmed + uniform mute state, treats mixed as off, does not guess for offline targets, + deduplicates successful writes, and resynchronizes after independent output + reconnect. Output failures remain surface-local and do not disable MIDI + input or audio operation. Hardware-free planner tests cover on/off, + deduplication, unavailable state, surface scoping, and reconnect refresh; + physical LED verification remains part of M6.1. - [ ] **M6.1 Output profiles:** mute LED/value/motor capabilities, output pairing, mixed-state policy. Tests: confirmed/internal and external changes reach all bound surfaces; outputless surfaces receive no unsupported message; pending/failed writes never produce false success feedback. - [ ] **M6.2 Feedback lifecycle:** attach snapshot, rate limits, deduplication, separate audio/output errors, documented device-specific echo suppression. Tests: feedback echoed as input cannot oscillate volume/mute; rapid updates converge; suppression does not swallow a genuine tested input sequence. - [ ] **M6.3 Extended controllers:** 14-bit CC/pitch bend, explicit relative encoder modes, motor output and touch handling for declared profiles. Tests: endpoints/byte-pair ordering, relative increments, no motor push while touched, and non-motorized profile never receives motor commands. Hardware-verify every shipped specialized profile.