use crate::change_frame;
use crate::juce_var::Value;
use crate::layout::Layout;
use crate::names::{
AppParam, AudioParam, BuildParam, ChannelParam, CurrentShowParam, DeviceModel, DuckerParam,
EffectsParam, Fader, FxPresetParam, GuiParam, HeadphoneParam, InputSourceParam, MasterParam,
MixMinusesParam, MixOutput, NetworkParam, OutputParam, PadParam, PadRecorderParam, PlayerParam,
RadioParam, RadioRxParam, RadioTxParam, RcSyncMixParam, RecorderParam, RecordingParam,
RecordingsParam, ShowControlParam, ShowParam, SipAdvancedParam, SipCallSlotsParam,
SipCallingParam, SipRegistrationParam, Source, StorageVolumeParam, StreamerXMixPresetParam,
StreamerXStreamMixParam, SystemParam, TestParam, ThemeParam, WifiScanResultParam,
};
#[cfg(test)]
const MIX_LINK_TRIGGER: [u8; 6] = crate::trigger::PRESS_BYTES;
const CHANNEL_INPUT_SOURCE_UNASSIGNED: i64 = -1;
const SCREEN_TOUCHED_FRAME: [u8; 18] = [
0x01, 0x01, 0x01, 0x01, b's', b'c', b'r', b'e', b'e', b'n', b'T', b'o', b'u', b'c', b'h', b'e',
b'd', 0x00,
];
const CALLME_MIX_PATH_OFFSET: u32 = 4;
#[inline]
fn single_prop_frame(path: &[u32], name: &str, value: &Value) -> Vec<Vec<u8>> {
vec![change_frame::encode_property_changed(path, name, value)]
}
#[inline]
fn trigger_frame(path: &[u32], name: &str) -> Vec<Vec<u8>> {
single_prop_frame(path, name, &crate::trigger::press_value())
}
macro_rules! encode_singleton {
($layout:expr, $getter:ident, $what:literal, $param:expr, $val:expr) => {{
let path = $layout
.$getter()
.ok_or(EncodeError::MissingNode { what: $what })?;
Ok(single_prop_frame(&path, $param.as_str(), $val))
}};
}
macro_rules! encode_indexed {
($layout:expr, $getter:ident, $idx:expr, $what:literal, $param:expr, $val:expr) => {{
let path = $layout
.$getter($idx)
.ok_or(EncodeError::MissingNode { what: $what })?;
Ok(single_prop_frame(&path, $param.as_str(), $val))
}};
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Command {
SetFaderMute { fader: Fader, mute: bool },
SetFaderCue { fader: Fader, enable: bool },
SetFaderLevel { fader: Fader, level: u8 },
AssignFaderSource {
fader: Fader,
source: Option<Source>,
},
SetMixDisabled {
source: Source,
mix: MixOutput,
disabled: bool,
},
SetMixMute {
source: Source,
mix: MixOutput,
mute: bool,
},
LinkMix { source: Source, mix: MixOutput },
UnlinkMix { source: Source, mix: MixOutput },
SetMixLevel {
source: Source,
mix: MixOutput,
anchor: f32,
value: f32,
},
ScreenTouched,
PowerOff,
LinkCallMe { source: Source, mix: MixOutput },
UnlinkCallMe { source: Source, mix: MixOutput },
SetChannelParam {
fader: Fader,
param: ChannelParam,
value: Value,
},
SetInputSourceParam {
source: Source,
param: InputSourceParam,
value: Value,
},
SetMasterParam { param: MasterParam, value: Value },
SetOutputParam { param: OutputParam, value: Value },
SetDuckerParam { param: DuckerParam, value: Value },
SetRecorderParam { param: RecorderParam, value: Value },
SetPlayerParam { param: PlayerParam, value: Value },
SetHeadphoneParam {
headphone: u8,
param: HeadphoneParam,
value: Value,
},
SetEffectsParam {
effects: u8,
param: EffectsParam,
value: Value,
},
SetGuiParam { param: GuiParam, value: Value },
SetPadParam {
pad: u8,
param: PadParam,
value: Value,
},
SetSystemParam { param: SystemParam, value: Value },
SetSipCallingParam {
param: SipCallingParam,
value: Value,
},
SetSipRegistrationParam {
registration: u8,
param: SipRegistrationParam,
value: Value,
},
SetSipCallSlotsParam {
slot: u8,
param: SipCallSlotsParam,
value: Value,
},
SetSipAdvancedParam {
param: SipAdvancedParam,
value: Value,
},
SetTestParam { param: TestParam, value: Value },
SetPadRecorderParam {
pad_recorder: u8,
param: PadRecorderParam,
value: Value,
},
SetFxPresetParam {
preset: u8,
param: FxPresetParam,
value: Value,
},
SetNetworkParam { param: NetworkParam, value: Value },
SetAudioParam { param: AudioParam, value: Value },
SetBuildParam { param: BuildParam, value: Value },
SetAppParam { param: AppParam, value: Value },
SetThemeParam { param: ThemeParam, value: Value },
SetCurrentShowParam {
param: CurrentShowParam,
value: Value,
},
SetShowControlParam {
param: ShowControlParam,
value: Value,
},
SetRecordingsParam {
param: RecordingsParam,
value: Value,
},
SetRadioParam { param: RadioParam, value: Value },
SetShowParam {
show: u8,
param: ShowParam,
value: Value,
},
SetRecordingParam {
recording: u8,
param: RecordingParam,
value: Value,
},
SetStorageVolumeParam {
volume: u8,
param: StorageVolumeParam,
value: Value,
},
SetRadioTxParam {
tx: u8,
param: RadioTxParam,
value: Value,
},
SetRadioRxParam {
rx: u8,
param: RadioRxParam,
value: Value,
},
SetWifiScanResultParam {
slot: u8,
param: WifiScanResultParam,
value: Value,
},
SetStreamerXMixPresetParam {
preset: u8,
param: StreamerXMixPresetParam,
value: Value,
},
SetStreamerXStreamMixParam {
stream: u8,
param: StreamerXStreamMixParam,
value: Value,
},
SetRcSyncMixParam {
mix: u8,
param: RcSyncMixParam,
value: Value,
},
SetMixMinusesParam {
minuses: u8,
param: MixMinusesParam,
value: Value,
},
SetupSkip {
language: Option<String>,
timezone: Option<String>,
},
}
impl Command {
pub fn encode(&self, layout: &Layout) -> Result<Vec<Vec<u8>>, EncodeError> {
match self {
Command::SetFaderMute { fader, mute } => {
let path = channel_path(layout, fader_index(layout, *fader)?)?;
Ok(vec![change_frame::encode_property_changed(
&path,
"channelOutputMute",
&Value::Bool(*mute),
)])
}
Command::SetFaderCue { fader, enable } => {
let path = channel_path(layout, fader_index(layout, *fader)?)?;
Ok(vec![change_frame::encode_property_changed(
&path,
"channelCueEnable",
&Value::Bool(*enable),
)])
}
Command::SetFaderLevel { fader, level } => {
let path = fader_path(layout, fader_index(layout, *fader)?)?;
Ok(vec![change_frame::encode_property_changed(
&path,
"faderLevel",
&Value::Int(*level as i64),
)])
}
Command::AssignFaderSource { fader, source } => {
let path = channel_path(layout, fader_index(layout, *fader)?)?;
let source_value = source
.map(|s| s.to_protocol() as i64)
.unwrap_or(CHANNEL_INPUT_SOURCE_UNASSIGNED);
Ok(vec![change_frame::encode_property_changed(
&path,
"channelInputSource",
&Value::Int(source_value),
)])
}
Command::SetMixDisabled {
source,
mix,
disabled,
} => {
let path = mix_path(layout, *source, *mix)?;
Ok(vec![change_frame::encode_property_changed(
&path,
"mixDisabled",
&Value::Bool(*disabled),
)])
}
Command::SetMixMute { source, mix, mute } => {
let path = mix_path(layout, *source, *mix)?;
Ok(vec![change_frame::encode_property_changed(
&path,
"mixMute",
&Value::Bool(*mute),
)])
}
Command::LinkMix { source, mix } => {
let path = mix_path(layout, *source, *mix)?;
Ok(vec![
change_frame::encode_property_changed(
&path,
"mixDisabled",
&Value::Bool(false),
),
change_frame::encode_property_changed(&path, "mixMute", &Value::Bool(false)),
change_frame::encode_property_changed(
&path,
"mixLinkRequest",
&crate::trigger::press_value(),
),
])
}
Command::UnlinkMix { source, mix } => {
let path = mix_path(layout, *source, *mix)?;
Ok(trigger_frame(&path, "mixUnlinkRequest"))
}
Command::SetMixLevel {
source,
mix,
anchor,
value,
} => {
let path = mix_path(layout, *source, *mix)?;
let formatted = format!("{:.1}|{:.1}", anchor, value);
Ok(single_prop_frame(
&path,
"mixLevelWithAnchor",
&Value::String(formatted),
))
}
Command::ScreenTouched => Ok(vec![SCREEN_TOUCHED_FRAME.to_vec()]),
Command::PowerOff => {
let path = layout
.system_path()
.ok_or(EncodeError::MissingNode { what: "SYSTEM" })?;
Ok(single_prop_frame(
&path,
"powerOffRequest",
&Value::Bool(true),
))
}
Command::LinkCallMe { source, mix } => Ok(trigger_frame(
&callme_request_path(*source, *mix),
"mixLinkRequest",
)),
Command::UnlinkCallMe { source, mix } => Ok(trigger_frame(
&callme_request_path(*source, *mix),
"mixUnlinkRequest",
)),
Command::SetChannelParam {
fader,
param,
value,
} => {
let path = channel_path(layout, fader_index(layout, *fader)?)?;
Ok(single_prop_frame(&path, param.as_str(), value))
}
Command::SetInputSourceParam {
source,
param,
value,
} => {
let path = input_source_path(layout, *source)?;
Ok(single_prop_frame(&path, param.as_str(), value))
}
Command::SetMasterParam { param, value } => {
encode_singleton!(layout, master_channel_path, "MASTERCHANNEL", param, value)
}
Command::SetOutputParam { param, value } => {
encode_singleton!(layout, output_path, "OUTPUT", param, value)
}
Command::SetDuckerParam { param, value } => {
encode_singleton!(layout, ducker_path, "DUCKER", param, value)
}
Command::SetRecorderParam { param, value } => {
encode_singleton!(layout, recorder_path, "RECORDER", param, value)
}
Command::SetPlayerParam { param, value } => {
encode_singleton!(layout, player_path, "PLAYER", param, value)
}
Command::SetHeadphoneParam {
headphone,
param,
value,
} => {
let path = headphone_path(layout, *headphone)?;
Ok(single_prop_frame(&path, param.as_str(), value))
}
Command::SetEffectsParam {
effects,
param,
value,
} => {
let path = effects_path(layout, *effects)?;
Ok(single_prop_frame(&path, param.as_str(), value))
}
Command::SetGuiParam { param, value } => {
encode_singleton!(layout, gui_path, "GUI", param, value)
}
Command::SetPadParam { pad, param, value } => {
let path = pad_path(layout, *pad)?;
Ok(single_prop_frame(&path, param.as_str(), value))
}
Command::SetSystemParam { param, value } => {
encode_singleton!(layout, system_path, "SYSTEM", param, value)
}
Command::SetSipCallingParam { param, value } => {
encode_singleton!(layout, sip_calling_path, "SIPCALLING", param, value)
}
Command::SetSipAdvancedParam { param, value } => {
encode_singleton!(layout, sip_advanced_path, "SIPADVANCED", param, value)
}
Command::SetSipRegistrationParam {
registration,
param,
value,
} => {
encode_indexed!(
layout,
sip_registration_path,
*registration,
"SIPREGISTRATION",
param,
value
)
}
Command::SetSipCallSlotsParam { slot, param, value } => {
encode_indexed!(
layout,
sip_call_slots_path,
*slot,
"SIPCALLSLOTS",
param,
value
)
}
Command::SetTestParam { param, value } => {
encode_singleton!(layout, test_path, "TEST", param, value)
}
Command::SetPadRecorderParam {
pad_recorder,
param,
value,
} => {
encode_indexed!(
layout,
pad_recorder_path,
*pad_recorder,
"PADRECORDER",
param,
value
)
}
Command::SetFxPresetParam {
preset,
param,
value,
} => {
encode_indexed!(layout, fx_preset_path, *preset, "FXPRESET", param, value)
}
Command::SetNetworkParam { param, value } => {
encode_singleton!(layout, network_path, "NETWORK", param, value)
}
Command::SetAudioParam { param, value } => {
encode_singleton!(layout, audio_path, "AUDIO", param, value)
}
Command::SetBuildParam { param, value } => {
encode_singleton!(layout, build_path, "BUILD", param, value)
}
Command::SetAppParam { param, value } => {
encode_singleton!(layout, app_path, "APP", param, value)
}
Command::SetThemeParam { param, value } => {
encode_singleton!(layout, theme_path, "THEME", param, value)
}
Command::SetCurrentShowParam { param, value } => {
encode_singleton!(layout, current_show_path, "CURRENTSHOW", param, value)
}
Command::SetShowControlParam { param, value } => {
encode_singleton!(layout, show_control_path, "SHOWCONTROL", param, value)
}
Command::SetRecordingsParam { param, value } => {
encode_singleton!(layout, recordings_path, "RECORDINGS", param, value)
}
Command::SetRadioParam { param, value } => {
encode_singleton!(layout, radio_path, "RADIO", param, value)
}
Command::SetShowParam { show, param, value } => {
encode_indexed!(layout, show_path, *show, "SHOW", param, value)
}
Command::SetRecordingParam {
recording,
param,
value,
} => {
encode_indexed!(
layout,
recording_path,
*recording,
"RECORDING",
param,
value
)
}
Command::SetStorageVolumeParam {
volume,
param,
value,
} => {
encode_indexed!(
layout,
storage_volume_path,
*volume,
"STORAGEVOLUME",
param,
value
)
}
Command::SetRadioTxParam { tx, param, value } => {
encode_indexed!(layout, radio_tx_path, *tx, "RADIOTX", param, value)
}
Command::SetRadioRxParam { rx, param, value } => {
encode_indexed!(layout, radio_rx_path, *rx, "RADIORX", param, value)
}
Command::SetWifiScanResultParam { slot, param, value } => {
encode_indexed!(
layout,
wifi_scan_result_path,
*slot,
"WIFISCANRESULT",
param,
value
)
}
Command::SetStreamerXMixPresetParam {
preset,
param,
value,
} => {
encode_indexed!(
layout,
streamerx_mix_preset_path,
*preset,
"STREAMERXMIXPRESET",
param,
value
)
}
Command::SetStreamerXStreamMixParam {
stream,
param,
value,
} => {
encode_indexed!(
layout,
streamerx_stream_mix_path,
*stream,
"STREAMERXSTREAMMIX",
param,
value
)
}
Command::SetRcSyncMixParam { mix, param, value } => {
encode_indexed!(layout, rcsync_mix_path, *mix, "RCSYNCMIX", param, value)
}
Command::SetMixMinusesParam {
minuses,
param,
value,
} => {
encode_indexed!(
layout,
mix_minuses_path,
*minuses,
"MIXMINUSES",
param,
value
)
}
Command::SetupSkip { language, timezone } => {
let mut frames = Vec::new();
if let Some(lang) = language {
if let Some(path) = layout.gui_path() {
frames.push(change_frame::encode_property_changed(
&path,
"lang",
&Value::String(lang.clone()),
));
}
}
if let Some(tz) = timezone {
if let Some(path) = layout.system_path() {
frames.push(change_frame::encode_property_changed(
&path,
"systemDateTimezone",
&Value::String(tz.clone()),
));
frames.push(change_frame::encode_property_changed(
&path,
"systemDateTime24h",
&Value::Bool(true),
));
frames.push(change_frame::encode_property_changed(
&path,
"systemDateTimeOnHome",
&Value::Bool(true),
));
}
}
if let Some(path) = layout.show_control_path() {
frames.push(change_frame::encode_property_changed(
&path,
"showControlNewFromDefaultMuted",
&Value::Bool(true),
));
}
if let Some(path) = layout.system_path() {
frames.push(change_frame::encode_property_changed(
&path,
"disableAllPhysicalButtons",
&Value::Bool(false),
));
frames.push(change_frame::encode_property_changed(
&path,
"disableAllLineoutOutputs",
&Value::Bool(false),
));
frames.push(change_frame::encode_property_changed(
&path,
"disableAllHeadphoneOutputs",
&Value::Bool(false),
));
frames.push(change_frame::encode_property_changed(
&path,
"systemChannelSelected",
&Value::Int(-1),
));
}
Ok(frames)
}
}
}
}
fn fader_index(layout: &Layout, fader: Fader) -> Result<u8, EncodeError> {
fader
.to_index(layout.model())
.ok_or(EncodeError::FaderNotOnModel {
fader,
model: layout.model(),
})
}
fn callme_request_path(source: Source, mix: MixOutput) -> Vec<u32> {
vec![((source.to_protocol() as u32) << 8) | (CALLME_MIX_PATH_OFFSET + mix.to_protocol() as u32)]
}
fn channel_path(layout: &Layout, idx: u8) -> Result<Vec<u32>, EncodeError> {
layout.channel_path(idx).ok_or(EncodeError::OutOfRange {
what: "fader",
index: idx as u32,
bound: layout.channel_count() as u32,
})
}
fn input_source_path(layout: &Layout, source: Source) -> Result<Vec<u32>, EncodeError> {
let idx = source.to_protocol();
layout
.input_source_path(idx)
.ok_or(EncodeError::OutOfRange {
what: "input source",
index: idx as u32,
bound: layout.input_source_count() as u32,
})
}
fn fader_path(layout: &Layout, idx: u8) -> Result<Vec<u32>, EncodeError> {
layout.fader_path(idx).ok_or(EncodeError::OutOfRange {
what: "fader",
index: idx as u32,
bound: layout.fader_count() as u32,
})
}
fn headphone_path(layout: &Layout, idx: u8) -> Result<Vec<u32>, EncodeError> {
layout.headphone_path(idx).ok_or(EncodeError::OutOfRange {
what: "headphone",
index: idx as u32,
bound: layout.headphone_count() as u32,
})
}
fn effects_path(layout: &Layout, idx: u8) -> Result<Vec<u32>, EncodeError> {
layout.effects_path(idx).ok_or(EncodeError::OutOfRange {
what: "effects",
index: idx as u32,
bound: layout.effects_count() as u32,
})
}
fn pad_path(layout: &Layout, idx: u8) -> Result<Vec<u32>, EncodeError> {
layout.pad_path(idx).ok_or(EncodeError::OutOfRange {
what: "pad",
index: idx as u32,
bound: layout.pad_count() as u32,
})
}
fn mix_path(layout: &Layout, source: Source, mix: MixOutput) -> Result<Vec<u32>, EncodeError> {
layout
.mix_cell_path(source.to_protocol(), mix.to_protocol())
.ok_or(EncodeError::MixCellOutOfRange {
source: source.to_protocol(),
mix: mix.to_protocol(),
source_bound: layout.source_count(),
mix_bound: layout.mix_count_per_source(),
})
}
#[derive(Debug, Clone, PartialEq)]
pub enum EncodeError {
OutOfRange {
what: &'static str,
index: u32,
bound: u32,
},
MixCellOutOfRange {
source: u8,
mix: u8,
source_bound: u8,
mix_bound: u8,
},
FaderNotOnModel { fader: Fader, model: DeviceModel },
MissingNode { what: &'static str },
}
impl std::fmt::Display for EncodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
EncodeError::OutOfRange { what, index, bound } => {
write!(f, "{what} index {index} out of range (bound {bound})")
}
EncodeError::FaderNotOnModel { fader, model } => {
write!(f, "fader {fader} does not exist on {model}")
}
EncodeError::MissingNode { what } => {
write!(f, "layout has no {what} node")
}
EncodeError::MixCellOutOfRange {
source,
mix,
source_bound,
mix_bound,
} => write!(
f,
"mix cell ({source}, {mix}) out of range (sources {source_bound}, mixes {mix_bound})"
),
}
}
}
impl std::error::Error for EncodeError {}
#[cfg(test)]
#[path = "commands_tests.rs"]
mod tests;