fader_master/config/src/profile.rs

1145 lines
34 KiB
Rust

use std::{
collections::{BTreeMap, BTreeSet},
time::Duration,
};
use fader_core::{
ApplicationId, ApplicationMatcher, ApplicationSelector as DomainSelector, FaderId, GroupId,
MetadataField, MidiChannel, MidiData, ProfileId, SurfaceId,
};
use serde::{Deserialize, Serialize};
use crate::{ConfigError, SCHEMA_VERSION};
const DEFAULT_POLL_INTERVAL_MS: u64 = 10;
const MIN_POLL_INTERVAL_MS: u64 = 1;
const MAX_POLL_INTERVAL_MS: u64 = 100;
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct RuntimeSettings {
#[serde(default = "default_poll_interval_ms")]
poll_interval_ms: u64,
}
impl Default for RuntimeSettings {
fn default() -> Self {
Self {
poll_interval_ms: DEFAULT_POLL_INTERVAL_MS,
}
}
}
const fn default_poll_interval_ms() -> u64 {
DEFAULT_POLL_INTERVAL_MS
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct UiSettings {
#[serde(default)]
mixer_orientation: MixerOrientation,
#[serde(default)]
status_display: StatusDisplayMode,
#[serde(default, skip_serializing_if = "Option::is_none")]
default_controller: Option<String>,
#[serde(default)]
theme: UiTheme,
}
/// Built-in terminal palette saved with a profile.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum UiTheme {
#[default]
Default,
Dracula,
Nord,
GruvboxDark,
CatppuccinMocha,
SolarizedDark,
}
/// Direction used to arrange fader displays in the mixer.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum MixerOrientation {
#[default]
Vertical,
Horizontal,
}
/// Amount and encoding of pickup status shown on mixer faders.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum StatusDisplayMode {
#[default]
Detailed,
Compact,
Symbol,
Color,
Hidden,
}
/// Behavior when a profile becomes active.
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum StartupPolicy {
/// Observe live audio without issuing writes.
Adopt,
/// Deliberately apply saved desired object state after discovery.
Restore,
}
/// Behavior when a new stream joins a configured application.
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum NewStreamPolicy {
/// Preserve the stream's live state.
Adopt,
/// Apply a saved desired value when one exists.
Restore,
}
/// Audio adapter selection value.
#[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum Adapter {
Auto,
Pulse,
Pipewire,
}
/// Validated audio selection and write ceiling.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Audio {
adapter: Adapter,
#[serde(default)]
preference: Vec<Adapter>,
max_gain: f64,
}
/// A validated virtual application.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Application {
id: String,
label: String,
selectors: Vec<Selector>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Selector {
field: SelectorField,
#[serde(skip_serializing_if = "Option::is_none")]
exact: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
regex: Option<String>,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum SelectorField {
#[serde(rename = "application.name")]
ApplicationName,
#[serde(rename = "application.id")]
ApplicationId,
#[serde(rename = "application.process.binary")]
ProcessBinary,
#[serde(rename = "media.name")]
MediaName,
}
impl SelectorField {
pub(crate) const fn as_str(self) -> &'static str {
match self {
Self::ApplicationName => "application.name",
Self::ApplicationId => "application.id",
Self::ProcessBinary => "application.process.binary",
Self::MediaName => "media.name",
}
}
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
enum VolumeMode {
Absolute,
Relative,
}
/// A validated non-nesting application group.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Group {
id: String,
label: String,
members: Vec<String>,
volume_mode: VolumeMode,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
enum IdentityPolicy {
RequireUnique,
Manual,
}
/// A configured physical control surface.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Surface {
id: String,
label: String,
input_port: String,
#[serde(skip_serializing_if = "Option::is_none")]
output_port: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
usb_vendor_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
usb_product_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
usb_serial: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
usb_path: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
manual_backend_id: Option<String>,
identity_policy: IdentityPolicy,
motorized: bool,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum TargetKind {
Application,
Group,
Output,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct Target {
kind: TargetKind,
id: String,
}
/// A logical fader targeting one application, group, or audio output.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Fader {
id: String,
target: Target,
pickup: bool,
pickup_tolerance: f64,
}
/// Vertical presentation density for one mixer fader.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum FaderDensity {
Slim,
BorderedSlim,
#[default]
Standard,
Thick,
}
/// Space reserved for a separator along the mixer layout axis.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SeparatorSize {
Slim,
#[default]
Standard,
Thick,
Fill,
}
/// Independent decoration for a separator.
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SeparatorDecoration {
Plain,
#[default]
Line,
Double,
Box,
}
/// One durable entry in the user-arranged mixer presentation.
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum MixerLayoutEntry {
/// A logical fader, optionally retained in place while hidden.
Fader {
fader: String,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
hidden: bool,
#[serde(default, skip_serializing_if = "is_standard_density")]
density: FaderDensity,
},
/// A presentation-only named divider.
Separator {
id: String,
label: String,
#[serde(default)]
size: SeparatorSize,
#[serde(default)]
decoration: SeparatorDecoration,
},
}
fn is_standard_density(density: &FaderDensity) -> bool {
*density == FaderDensity::Standard
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Action {
Volume,
ToggleMute,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum MessageKind {
Cc,
Note,
}
#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(deny_unknown_fields)]
struct Message {
kind: MessageKind,
channel: u16,
number: u16,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
enum Edge {
Press,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Feedback {
kind: MessageKind,
channel: u16,
number: u16,
on: u16,
off: u16,
}
/// A validated physical-message-to-logical-fader binding.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Binding {
surface: String,
fader: String,
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
edge: Option<Edge>,
message: Message,
#[serde(skip_serializing_if = "Option::is_none")]
feedback: Option<Feedback>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct RawProfile {
schema_version: u16,
id: String,
startup: StartupPolicy,
new_stream: NewStreamPolicy,
#[serde(default)]
runtime: RuntimeSettings,
#[serde(default)]
ui: UiSettings,
audio: Audio,
#[serde(default)]
applications: Vec<Application>,
#[serde(default)]
groups: Vec<Group>,
#[serde(default)]
surfaces: Vec<Surface>,
#[serde(default)]
faders: Vec<Fader>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
mixer_layout: Vec<MixerLayoutEntry>,
#[serde(default)]
bindings: Vec<Binding>,
}
/// A complete, semantically validated runtime profile document.
#[derive(Clone, Debug, PartialEq)]
pub struct Profile {
raw: RawProfile,
id: ProfileId,
mixer_layout: Vec<MixerLayoutEntry>,
}
impl Profile {
/// Parses strict TOML and validates all cross-document invariants.
pub fn parse(input: &str) -> Result<Self, ConfigError> {
let raw: RawProfile = toml::from_str(input)?;
validate_version(raw.schema_version)?;
let id = parse_id::<ProfileId>(&raw.id, "profile.id")?;
validate_runtime(&raw.runtime)?;
validate_audio(&raw.audio)?;
validate_profile_members(&raw)?;
let mixer_layout = effective_mixer_layout(&raw);
Ok(Self {
raw,
id,
mixer_layout,
})
}
/// Serializes a canonical representation of this validated profile.
pub fn to_toml(&self) -> Result<String, ConfigError> {
Ok(toml::to_string_pretty(&self.raw)?)
}
/// Stable profile identifier.
pub fn id(&self) -> &ProfileId {
&self.id
}
/// Startup state policy.
pub const fn startup(&self) -> StartupPolicy {
self.raw.startup
}
/// Policy for streams first observed after profile activation.
#[must_use]
pub const fn new_stream(&self) -> NewStreamPolicy {
self.raw.new_stream
}
/// Validated audio adapter selection and preference order.
pub const fn audio(&self) -> &Audio {
&self.raw.audio
}
/// Applications in declared order.
pub fn applications(&self) -> &[Application] {
&self.raw.applications
}
/// Groups in declared restore-conflict order.
pub fn groups(&self) -> &[Group] {
&self.raw.groups
}
/// Configured MIDI surfaces in declared order.
pub fn surfaces(&self) -> &[Surface] {
&self.raw.surfaces
}
pub fn faders(&self) -> &[Fader] {
&self.raw.faders
}
/// Ordered effective mixer presentation, including synthesized legacy entries.
pub fn mixer_layout(&self) -> &[MixerLayoutEntry] {
&self.mixer_layout
}
/// Direction used to arrange fader displays in the mixer.
pub const fn mixer_orientation(&self) -> MixerOrientation {
self.raw.ui.mixer_orientation
}
/// Preferred pickup-status presentation in the terminal mixer.
pub const fn status_display(&self) -> StatusDisplayMode {
self.raw.ui.status_display
}
/// Surface selected automatically for new MIDI assignments in the TUI.
pub fn default_controller(&self) -> Option<&str> {
self.raw.ui.default_controller.as_deref()
}
/// Saved terminal palette for this profile.
pub const fn theme(&self) -> UiTheme {
self.raw.ui.theme
}
/// Validated bindings.
pub fn bindings(&self) -> &[Binding] {
&self.raw.bindings
}
/// Resolves explicit feedback first, then same-note mute feedback.
///
/// Note mute bindings default to their input channel/note, with on=127 and
/// off=0, whenever the surface has an output. Other protocols are explicit.
/// This does not rewrite the document or override an explicit mapping.
pub fn effective_feedback(&self, binding: &Binding) -> Option<Feedback> {
if let Some(feedback) = binding.feedback() {
return Some(feedback.clone());
}
let surface = self
.surfaces()
.iter()
.find(|surface| surface.id() == binding.surface())?;
if surface.output_port().is_none()
|| binding.action() != Action::ToggleMute
|| binding.message_kind() != MessageKind::Note
{
return None;
}
Some(Feedback {
kind: MessageKind::Note,
channel: binding.channel(),
number: binding.number(),
on: 127,
off: 0,
})
}
/// Maximum configured gain for outbound writes and restored intents.
pub fn max_gain(&self) -> f64 {
self.raw.audio.max_gain
}
/// Interval used by the server and native audio worker while waiting for
/// MIDI, IPC, adapter commands, and subscription notifications.
#[must_use]
pub const fn poll_interval(&self) -> Duration {
Duration::from_millis(self.raw.runtime.poll_interval_ms)
}
}
impl Audio {
/// Configured automatic or manual adapter choice.
#[must_use]
pub const fn adapter(&self) -> Adapter {
self.adapter
}
/// Concrete automatic-probe order; an empty list uses runtime defaults.
#[must_use]
pub fn preference(&self) -> &[Adapter] {
&self.preference
}
/// Maximum configured gain for outbound writes.
#[must_use]
pub const fn max_gain(&self) -> f64 {
self.max_gain
}
}
impl Application {
/// Stable application identifier from the validated profile.
#[must_use]
pub fn id(&self) -> &str {
&self.id
}
/// User-facing application label.
#[must_use]
pub fn label(&self) -> &str {
&self.label
}
/// Ordered capture selectors used by this virtual application.
#[must_use]
pub fn selectors(&self) -> &[Selector] {
&self.selectors
}
/// Compiles this validated application's selectors for live stream matching.
pub fn matcher(&self) -> Result<ApplicationMatcher, ConfigError> {
let id = parse_id::<ApplicationId>(&self.id, "application.id")?;
let selectors = self
.selectors
.iter()
.map(Selector::compile)
.collect::<Result<Vec<_>, _>>()?;
ApplicationMatcher::new(id, selectors)
.map_err(|error| ConfigError::validation("application.selectors", error.to_string()))
}
}
impl Selector {
/// Normalized metadata field tested by this selector.
#[must_use]
pub const fn field(&self) -> SelectorField {
self.field
}
/// Exact or regex source pattern and whether regex mode is active.
#[must_use]
pub fn pattern(&self) -> (&str, bool) {
match (&self.exact, &self.regex) {
(Some(pattern), None) => (pattern, false),
(None, Some(pattern)) => (pattern, true),
_ => ("", false),
}
}
fn compile(&self) -> Result<DomainSelector, ConfigError> {
let field = match self.field {
SelectorField::ApplicationName => MetadataField::ApplicationName,
SelectorField::ApplicationId => MetadataField::ApplicationId,
SelectorField::ProcessBinary => MetadataField::ProcessBinary,
SelectorField::MediaName => MetadataField::MediaName,
};
match (&self.exact, &self.regex) {
(Some(pattern), None) => DomainSelector::exact(field, pattern),
(None, Some(pattern)) => DomainSelector::regex(field, pattern),
_ => {
return Err(ConfigError::validation(
"application.selector",
"exactly one of exact or regex is required",
));
}
}
.map_err(|error| ConfigError::validation("application.selector", error.to_string()))
}
}
impl Group {
/// Stable group identifier from the validated profile.
#[must_use]
pub fn id(&self) -> &str {
&self.id
}
/// User-facing group label.
#[must_use]
pub fn label(&self) -> &str {
&self.label
}
/// Stable application IDs included in this group.
#[must_use]
pub fn members(&self) -> &[String] {
&self.members
}
/// Group gain semantics used when planning writes.
#[must_use]
pub const fn volume_mode(&self) -> fader_core::VolumeMode {
match self.volume_mode {
VolumeMode::Absolute => fader_core::VolumeMode::Absolute,
VolumeMode::Relative => fader_core::VolumeMode::Relative,
}
}
}
impl Surface {
/// Stable user-assigned surface identifier.
#[must_use]
pub fn id(&self) -> &str {
&self.id
}
/// User-facing surface label.
#[must_use]
pub fn label(&self) -> &str {
&self.label
}
/// Stable portion of the expected MIDI input-port name.
#[must_use]
pub fn input_port(&self) -> &str {
&self.input_port
}
/// Optional independently assigned output-port name.
#[must_use]
pub fn output_port(&self) -> Option<&str> {
self.output_port.as_deref()
}
#[must_use]
pub fn usb_vendor_id(&self) -> Option<&str> {
self.usb_vendor_id.as_deref()
}
#[must_use]
pub fn usb_product_id(&self) -> Option<&str> {
self.usb_product_id.as_deref()
}
#[must_use]
pub fn usb_serial(&self) -> Option<&str> {
self.usb_serial.as_deref()
}
#[must_use]
pub fn usb_path(&self) -> Option<&str> {
self.usb_path.as_deref()
}
/// Explicit current backend selection used only to resolve ambiguity.
#[must_use]
pub fn manual_backend_id(&self) -> Option<&str> {
self.manual_backend_id.as_deref()
}
}
impl Fader {
pub fn id(&self) -> &str {
&self.id
}
pub const fn target_kind(&self) -> TargetKind {
self.target.kind
}
pub fn target_id(&self) -> &str {
&self.target.id
}
pub const fn pickup(&self) -> bool {
self.pickup
}
pub const fn pickup_tolerance(&self) -> f64 {
self.pickup_tolerance
}
}
impl Binding {
pub fn surface(&self) -> &str {
&self.surface
}
pub fn fader(&self) -> &str {
&self.fader
}
pub const fn action(&self) -> Action {
self.action
}
pub const fn message_kind(&self) -> MessageKind {
self.message.kind
}
pub const fn channel(&self) -> u16 {
self.message.channel
}
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> {
if version == SCHEMA_VERSION {
Ok(())
} else {
Err(ConfigError::validation(
"schema_version",
format!("unsupported version {version}; expected {SCHEMA_VERSION}"),
))
}
}
fn validate_runtime(runtime: &RuntimeSettings) -> Result<(), ConfigError> {
if (MIN_POLL_INTERVAL_MS..=MAX_POLL_INTERVAL_MS).contains(&runtime.poll_interval_ms) {
Ok(())
} else {
Err(ConfigError::validation(
"runtime.poll_interval_ms",
format!("must be within {MIN_POLL_INTERVAL_MS}..={MAX_POLL_INTERVAL_MS}"),
))
}
}
fn validate_audio(audio: &Audio) -> Result<(), ConfigError> {
if !audio.max_gain.is_finite() || audio.max_gain < 0.0 {
return Err(ConfigError::validation(
"audio.max_gain",
"must be finite and non-negative",
));
}
let mut seen = BTreeSet::new();
for (index, adapter) in audio.preference.iter().enumerate() {
if *adapter == Adapter::Auto {
return Err(ConfigError::validation(
format!("audio.preference[{index}]"),
"auto is a selection policy, not a concrete adapter",
));
}
if !seen.insert(adapter) {
return Err(ConfigError::validation(
format!("audio.preference[{index}]"),
"duplicate adapter",
));
}
}
Ok(())
}
fn validate_profile_members(raw: &RawProfile) -> Result<(), ConfigError> {
let applications = unique_ids::<ApplicationId, _>(
raw.applications.iter().map(|item| item.id.as_str()),
"applications",
)?;
for (index, application) in raw.applications.iter().enumerate() {
if application.selectors.is_empty() {
return Err(ConfigError::validation(
format!("applications[{index}].selectors"),
"at least one selector is required",
));
}
for (selector_index, selector) in application.selectors.iter().enumerate() {
validate_selector(selector, index, selector_index)?;
}
}
let groups =
unique_ids::<GroupId, _>(raw.groups.iter().map(|item| item.id.as_str()), "groups")?;
for (index, group) in raw.groups.iter().enumerate() {
if group.volume_mode == VolumeMode::Relative {
return Err(ConfigError::validation(
format!("groups[{index}].volume_mode"),
"relative groups are reserved for a future stateful runtime; use absolute",
));
}
let mut members = BTreeSet::new();
for (member_index, member) in group.members.iter().enumerate() {
let member_id = parse_id::<ApplicationId>(
member,
&format!("groups[{index}].members[{member_index}]"),
)?;
if !applications.contains_key(member_id.as_str()) {
return Err(ConfigError::validation(
format!("groups[{index}].members[{member_index}]"),
format!("unknown application {member:?}"),
));
}
if !members.insert(member) {
return Err(ConfigError::validation(
format!("groups[{index}].members[{member_index}]"),
"duplicate member",
));
}
}
}
let surfaces =
unique_ids::<SurfaceId, _>(raw.surfaces.iter().map(|item| item.id.as_str()), "surfaces")?;
if let Some(default_controller) = &raw.ui.default_controller {
parse_id::<SurfaceId>(default_controller, "ui.default_controller")?;
if !surfaces.contains_key(default_controller) {
return Err(ConfigError::validation(
"ui.default_controller",
format!("unknown surface {default_controller:?}"),
));
}
}
for (index, surface) in raw.surfaces.iter().enumerate() {
if surface.input_port.is_empty() {
return Err(ConfigError::validation(
format!("surfaces[{index}].input_port"),
"must not be empty",
));
}
if surface.motorized && surface.output_port.is_none() {
return Err(ConfigError::validation(
format!("surfaces[{index}].output_port"),
"a motorized surface requires an output port",
));
}
match (&surface.usb_vendor_id, &surface.usb_product_id) {
(Some(vendor), Some(product)) => {
validate_usb_id(vendor, &format!("surfaces[{index}].usb_vendor_id"))?;
validate_usb_id(product, &format!("surfaces[{index}].usb_product_id"))?;
}
(None, None) => {}
_ => {
return Err(ConfigError::validation(
format!("surfaces[{index}].usb_vendor_id"),
"USB vendor_id and product_id must be provided together",
));
}
}
for (field, value) in [
("usb_serial", surface.usb_serial.as_deref()),
("usb_path", surface.usb_path.as_deref()),
("manual_backend_id", surface.manual_backend_id.as_deref()),
] {
if value.is_some_and(str::is_empty) {
return Err(ConfigError::validation(
format!("surfaces[{index}].{field}"),
"must not be empty",
));
}
}
}
let faders =
unique_ids::<FaderId, _>(raw.faders.iter().map(|item| item.id.as_str()), "faders")?;
for (index, fader) in raw.faders.iter().enumerate() {
if !fader.pickup_tolerance.is_finite() || !(0.0..=1.0).contains(&fader.pickup_tolerance) {
return Err(ConfigError::validation(
format!("faders[{index}].pickup_tolerance"),
"must be finite and within 0..=1",
));
}
let found = match fader.target.kind {
TargetKind::Application => applications.contains_key(&fader.target.id),
TargetKind::Group => groups.contains_key(&fader.target.id),
TargetKind::Output => fader.target.id == "default",
};
if !found {
return Err(ConfigError::validation(
format!("faders[{index}].target.id"),
format!("unknown {:?} {:?}", fader.target.kind, fader.target.id),
));
}
}
validate_mixer_layout(raw, &faders)?;
validate_bindings(raw, &surfaces, &faders)
}
fn validate_mixer_layout(
raw: &RawProfile,
faders: &BTreeMap<String, FaderId>,
) -> Result<(), ConfigError> {
let mut ids = BTreeSet::new();
let mut referenced_faders = BTreeSet::new();
for (index, entry) in raw.mixer_layout.iter().enumerate() {
let (id, is_fader) = match entry {
MixerLayoutEntry::Fader { fader, .. } => {
parse_id::<FaderId>(fader, &format!("mixer_layout[{index}].fader"))?;
if !faders.contains_key(fader) {
return Err(ConfigError::validation(
format!("mixer_layout[{index}].fader"),
format!("unknown fader {fader:?}"),
));
}
if !referenced_faders.insert(fader.as_str()) {
return Err(ConfigError::validation(
format!("mixer_layout[{index}].fader"),
"duplicate fader",
));
}
(fader, true)
}
MixerLayoutEntry::Separator { id, .. } => {
parse_id::<FaderId>(id, &format!("mixer_layout[{index}].id"))?;
(id, false)
}
};
if !ids.insert(id.as_str()) {
let kind = if is_fader { "fader" } else { "separator" };
return Err(ConfigError::validation(
format!("mixer_layout[{index}]"),
format!("duplicate layout id for {kind} {id:?}"),
));
}
}
Ok(())
}
fn effective_mixer_layout(raw: &RawProfile) -> Vec<MixerLayoutEntry> {
let mut layout = raw.mixer_layout.clone();
let referenced = layout
.iter()
.filter_map(|entry| match entry {
MixerLayoutEntry::Fader { fader, .. } => Some(fader.clone()),
MixerLayoutEntry::Separator { .. } => None,
})
.collect::<BTreeSet<_>>();
layout.extend(
raw.faders
.iter()
.filter(|fader| !referenced.contains(&fader.id))
.map(|fader| MixerLayoutEntry::Fader {
fader: fader.id.clone(),
hidden: false,
density: FaderDensity::Standard,
}),
);
layout
}
fn validate_usb_id(value: &str, path: &str) -> Result<(), ConfigError> {
if value.len() == 4 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
Ok(())
} else {
Err(ConfigError::validation(
path,
"must contain exactly four hexadecimal digits",
))
}
}
fn validate_selector(
selector: &Selector,
application: usize,
index: usize,
) -> Result<(), ConfigError> {
let path = format!("applications[{application}].selectors[{index}]");
let field = match selector.field {
SelectorField::ApplicationName => MetadataField::ApplicationName,
SelectorField::ApplicationId => MetadataField::ApplicationId,
SelectorField::ProcessBinary => MetadataField::ProcessBinary,
SelectorField::MediaName => MetadataField::MediaName,
};
match (&selector.exact, &selector.regex) {
(Some(pattern), None) => DomainSelector::exact(field, pattern)
.map(|_| ())
.map_err(|error| ConfigError::validation(format!("{path}.exact"), error.to_string())),
(None, Some(pattern)) => DomainSelector::regex(field, pattern)
.map(|_| ())
.map_err(|error| ConfigError::validation(format!("{path}.regex"), error.to_string())),
_ => Err(ConfigError::validation(
path,
"exactly one of exact or regex is required",
)),
}
}
fn validate_bindings(
raw: &RawProfile,
surfaces: &BTreeMap<String, SurfaceId>,
faders: &BTreeMap<String, FaderId>,
) -> Result<(), ConfigError> {
let mut physical = BTreeSet::new();
for (index, binding) in raw.bindings.iter().enumerate() {
if !surfaces.contains_key(&binding.surface) {
return Err(ConfigError::validation(
format!("bindings[{index}].surface"),
format!("unknown surface {:?}", binding.surface),
));
}
if !faders.contains_key(&binding.fader) {
return Err(ConfigError::validation(
format!("bindings[{index}].fader"),
format!("unknown fader {:?}", binding.fader),
));
}
validate_message(&binding.message, &format!("bindings[{index}].message"))?;
let key = (&binding.surface, binding.message.clone());
if !physical.insert(key) {
return Err(ConfigError::validation(
format!("bindings[{index}].message"),
"duplicate physical binding for this surface",
));
}
match (binding.action, binding.message.kind, binding.edge) {
(Action::Volume, MessageKind::Cc, None) => {}
(Action::Volume, _, _) => {
return Err(ConfigError::validation(
format!("bindings[{index}].action"),
"volume requires a cc message and no edge",
));
}
(Action::ToggleMute, _, Some(Edge::Press)) => {}
(Action::ToggleMute, _, None) => {
return Err(ConfigError::validation(
format!("bindings[{index}].edge"),
"toggle_mute requires edge = press",
));
}
}
if let Some(feedback) = &binding.feedback {
let surface = raw
.surfaces
.iter()
.find(|surface| surface.id == binding.surface)
.expect("validated surface lookup is consistent");
if surface.output_port.is_none() {
return Err(ConfigError::validation(
format!("bindings[{index}].feedback"),
"surface output_port is required for feedback",
));
}
validate_feedback(feedback, &format!("bindings[{index}].feedback"))?;
}
}
Ok(())
}
fn validate_message(message: &Message, path: &str) -> Result<(), ConfigError> {
MidiChannel::new(message.channel)
.map_err(|error| ConfigError::validation(format!("{path}.channel"), error.to_string()))?;
MidiData::new(message.number)
.map_err(|error| ConfigError::validation(format!("{path}.number"), error.to_string()))?;
Ok(())
}
fn validate_feedback(feedback: &Feedback, path: &str) -> Result<(), ConfigError> {
validate_message(
&Message {
kind: feedback.kind,
channel: feedback.channel,
number: feedback.number,
},
path,
)?;
MidiData::new(feedback.on)
.map_err(|error| ConfigError::validation(format!("{path}.on"), error.to_string()))?;
MidiData::new(feedback.off)
.map_err(|error| ConfigError::validation(format!("{path}.off"), error.to_string()))?;
Ok(())
}
fn unique_ids<T, I>(values: I, collection: &str) -> Result<BTreeMap<String, T>, ConfigError>
where
T: std::str::FromStr,
T::Err: std::fmt::Display,
I: IntoIterator,
I::Item: AsRef<str>,
{
let mut result = BTreeMap::new();
for (index, value) in values.into_iter().enumerate() {
let value = value.as_ref();
let id = parse_id::<T>(value, &format!("{collection}[{index}].id"))?;
if result.insert(value.to_owned(), id).is_some() {
return Err(ConfigError::validation(
format!("{collection}[{index}].id"),
format!("duplicate ID {value:?}"),
));
}
}
Ok(result)
}
pub(crate) fn parse_id<T>(value: &str, path: &str) -> Result<T, ConfigError>
where
T: std::str::FromStr,
T::Err: std::fmt::Display,
{
value
.parse()
.map_err(|error: T::Err| ConfigError::validation(path, error.to_string()))
}