diff --git a/src/dsp408/client/dsp408.rs b/src/dsp408/client/dsp408.rs index ad40096..531a60f 100644 --- a/src/dsp408/client/dsp408.rs +++ b/src/dsp408/client/dsp408.rs @@ -18,7 +18,7 @@ use crate::{ response::map_response, }, protocol::{commands, config::decode_config, frame::extract_frame}, - types::{self, DSPMode}, + types::{self, ConnectionStatus::Disconnected, DSPMode}, }, }; @@ -57,7 +57,7 @@ impl DSP408 { } Ok(Self { - mode: types::DSPMode::Disconnected, + mode: types::DSPMode::Normal, connection: types::DeviceConnection { host, @@ -140,7 +140,7 @@ impl DSP408 { } pub fn connected(&self) -> bool { - self.mode == types::DSPMode::Connected + self.state.connection == types::ConnectionStatus::Connected } pub fn demo(&self) -> bool { @@ -185,6 +185,7 @@ impl DSP408 { modified: modified.modified, }, current_config: state, + connection: Disconnected, }; Ok(()) @@ -201,10 +202,11 @@ impl DSP408 { // Command `0x10` pub fn connect(&mut self) -> Result<(), DSPError> { if self.mode == types::DSPMode::Demo { + self.state.connection = types::ConnectionStatus::Connected; return Ok(()); } - if self.mode == types::DSPMode::Connected { + if self.state.connection == types::ConnectionStatus::Connected { return Err(DSPError::AlreadyConnected); } @@ -271,7 +273,7 @@ impl DSP408 { return Err(error); } - self.mode = types::DSPMode::Connected; + self.state.connection = types::ConnectionStatus::Connected; instances() .lock() @@ -289,6 +291,11 @@ impl DSP408 { // Command `0x11` pub fn disconnect(&mut self) -> Result<(), DSPError> { + if self.mode == types::DSPMode::Demo { + self.state.connection = types::ConnectionStatus::Disconnected; + return Ok(()); + } + let key = (self.connection.host, self.connection.device_id); let mut socket_guard = self @@ -306,9 +313,7 @@ impl DSP408 { .map_err(|e| DSPError::MutexPoisoned(e.to_string()))? .remove(&key); - if self.mode == types::DSPMode::Connected { - self.mode = types::DSPMode::Disconnected; - } + self.state.connection = types::ConnectionStatus::Disconnected; Ok(()) } @@ -362,33 +367,31 @@ impl DSP408 { pub fn set_delay_unit(&mut self, unit: types::DelayUnit) -> Result { let raw_unit = mapper::delay_unit_to_raw(unit)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_delay_unit(raw_unit)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_delay_unit(raw_unit)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -416,34 +419,35 @@ impl DSP408 { pub fn recall_preset(&mut self, preset_index: usize) -> Result { let raw_index = mapper::preset_index_to_raw(preset_index)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_recall(raw_index)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_recall(raw_index)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } + + let config = self.read_config_state()?; + self.state_mut().current_config = config; } - let config = self.read_config_state()?; - self.state_mut().current_config = config; - } - - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } + } else if self.mode == types::DSPMode::Demo { + self.state = default_dsp_state(); } } - types::DSPMode::Demo => { - self.state = default_dsp_state(); - } - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -465,35 +469,36 @@ impl DSP408 { return Ok(false); } - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_store_current_configuration(raw_index)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_store_current_configuration(raw_index)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } + } + + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); } } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + if !self.request_acknowledgement()? { + return Err(DSPError::OperationFailed( + "Store Configuration failed".into(), + )); } } - - if !self.request_acknowledgement()? { - return Err(DSPError::OperationFailed( - "Store Configuration failed".into(), - )); - } } - types::DSPMode::Demo => {} - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -524,36 +529,33 @@ impl DSP408 { return Ok(false); } - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_factory_reset(); + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_factory_reset(); - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } + } + + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); } } - - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); - } + } else if self.mode == types::DSPMode::Demo { + self.state = default_dsp_state(); } - - // Hardware accepted the reset. - self.state = default_dsp_state(); } - types::DSPMode::Demo => { - self.state = default_dsp_state(); - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -565,41 +567,40 @@ impl DSP408 { pub fn set_current_preset_name(&mut self, name: &str) -> Result { let raw_name = mapper::preset_name_to_raw(name)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_store_current_preset_name(&raw_name)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_store_current_preset_name(&raw_name)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } + } + + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); } } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + let current_index = self.state().presets.current_index; + + if !self.store_current_configuration(current_index, true)? { + return Ok(false); + } + + if !self.request_acknowledgement()? { + return Ok(false); } } - - let current_index = self.state().presets.current_index; - - if !self.store_current_configuration(current_index, true)? { - return Ok(false); - } - - if !self.request_acknowledgement()? { - return Ok(false); - } } - types::DSPMode::Demo => { - // No hardware operations. - } - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -704,33 +705,31 @@ impl DSP408 { ) -> Result { let (raw_channel_1, raw_channel_2) = mapper::copy_channel_to_raw(channel_1, channel_2)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_copy_channel(raw_channel_1, raw_channel_2)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_copy_channel(raw_channel_1, raw_channel_2)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -759,33 +758,31 @@ impl DSP408 { pub fn unlock_device(&mut self, password: &str) -> Result { let raw_password = mapper::password_to_raw(password)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_unlock_device(&raw_password)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_unlock_device(&raw_password)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::AuthenticationResult(result) => { - if !result.success { - return Ok(false); + match resp { + types::DeviceResponseType::AuthenticationResult(result) => { + if !result.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected AuthenticationResult, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected AuthenticationResult, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // Emulate successful unlock locally. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -799,39 +796,39 @@ impl DSP408 { pub fn lock_device(&mut self, password: &str) -> Result { let raw_password = mapper::password_to_raw(password)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_lock_device(&raw_password)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_lock_device(&raw_password)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // Emulate locking locally. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } self.state_mut().flags.is_locked = true; + self.disconnect()?; + Ok(true) } @@ -852,40 +849,38 @@ impl DSP408 { let raw_knee = mapper::knee_db_to_raw(knee)?; let raw_threshold = mapper::threshold_db_to_raw(threshold)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_compressor( - raw_channel, - raw_ratio, - raw_attack, - raw_release, - raw_knee, - raw_threshold, - )?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_compressor( + raw_channel, + raw_ratio, + raw_attack, + raw_release, + raw_knee, + raw_threshold, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -916,33 +911,31 @@ impl DSP408 { let raw_freq = mapper::frequency_hz_to_raw(freq)?; let raw_filter = mapper::crossover_filter_to_raw(filter_type)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_low_pass(raw_channel, raw_freq, raw_filter)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_low_pass(raw_channel, raw_freq, raw_filter)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -987,33 +980,31 @@ impl DSP408 { let raw_freq = mapper::frequency_hz_to_raw(freq)?; let raw_filter = mapper::crossover_filter_to_raw(filter_type)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_high_pass(raw_channel, raw_freq, raw_filter)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_high_pass(raw_channel, raw_freq, raw_filter)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1066,41 +1057,39 @@ impl DSP408 { let raw_q = mapper::peq_q_to_raw(q, filter_type)?; let raw_filter = mapper::peq_filter_to_raw(filter_type)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_peq_band( - raw_channel, - raw_band, - raw_gain, - raw_frequency, - raw_q, - raw_filter, - bypass as u8, - )?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_peq_band( + raw_channel, + raw_band, + raw_gain, + raw_frequency, + raw_q, + raw_filter, + bypass as u8, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1144,33 +1133,31 @@ impl DSP408 { let raw_channel = mapper::channel_to_raw(channel)?; let raw_db = mapper::gain_db_to_raw(db)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_gain(raw_channel, raw_db)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_gain(raw_channel, raw_db)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1194,33 +1181,31 @@ impl DSP408 { pub fn set_mute(&mut self, channel: types::Channel, muted: bool) -> Result { let raw_channel = mapper::channel_to_raw(channel)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_mute(raw_channel, muted as u8)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_mute(raw_channel, muted as u8)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1248,33 +1233,31 @@ impl DSP408 { ) -> Result { let raw_channel = mapper::channel_to_raw(channel)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_inverted_gain(raw_channel, inverted as u8)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_inverted_gain(raw_channel, inverted as u8)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1304,33 +1287,31 @@ impl DSP408 { let raw_channel = mapper::channel_to_raw(channel)?; let raw_delay = mapper::delay_to_raw(delay, unit)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_delay(raw_channel, raw_delay)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_delay(raw_channel, raw_delay)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1356,33 +1337,31 @@ impl DSP408 { let raw_source = mapper::input_source_to_raw(input_source.r#type)?; let raw_frequency = mapper::frequency_value_to_raw(input_source.frequency)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_input_source(raw_source, raw_frequency)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_input_source(raw_source, raw_frequency)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1404,33 +1383,31 @@ impl DSP408 { let raw_output = mapper::output_channel_to_raw(output)?; let raw_inputs = mapper::matrix_to_raw(&inputs)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_matrix_routing(raw_output, raw_inputs)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_matrix_routing(raw_output, raw_inputs)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1466,37 +1443,11 @@ impl DSP408 { } } - match self.mode { - types::DSPMode::Connected => { - // Link source - let request = commands::build_link_channel(raw_source, bitmask)?; - - let resp = self.send_recv(&request)?; - - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); - } - } - - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); - } - } - - // Clear destination links - for destination in &destinations { - if *destination == source { - continue; - } - - let raw_destination = mapper::channel_to_raw(*destination)?; - - let request = commands::build_link_channel(raw_destination, 0x00)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + // Link source + let request = commands::build_link_channel(raw_source, bitmask)?; let resp = self.send_recv(&request)?; @@ -1514,18 +1465,42 @@ impl DSP408 { ))); } } - } - if !self.request_acknowledgement()? { - return Ok(false); + // Clear destination links + for destination in &destinations { + if *destination == source { + continue; + } + + let raw_destination = mapper::channel_to_raw(*destination)?; + + let request = commands::build_link_channel(raw_destination, 0x00)?; + + let resp = self.send_recv(&request)?; + + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } + } + + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } + } + } + + if !self.request_acknowledgement()? { + return Ok(false); + } } } - types::DSPMode::Demo => { - // Copy already applied above; nothing else to reconcile. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1589,33 +1564,31 @@ impl DSP408 { ) -> Result { let raw_channel = mapper::channel_to_raw(channel)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_bypass_peq(raw_channel, bypass as u8)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_bypass_peq(raw_channel, bypass as u8)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1648,33 +1621,31 @@ impl DSP408 { let raw_channel = mapper::channel_to_raw(channel)?; let raw_name = mapper::channel_name_to_raw(name)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_store_channel_name(raw_channel, &raw_name)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_store_channel_name(raw_channel, &raw_name)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1711,39 +1682,37 @@ impl DSP408 { let raw_hold = mapper::hold_ms_to_raw(hold)?; let raw_release = mapper::release_ms_to_raw(release)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_gate( - raw_channel, - raw_threshold, - raw_attack, - raw_hold, - raw_release, - )?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_gate( + raw_channel, + raw_threshold, + raw_attack, + raw_hold, + raw_release, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1774,38 +1743,36 @@ impl DSP408 { let raw_attack = mapper::attack_ms_to_raw(attack)?; let raw_release = mapper::release_ms_to_raw(release)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_limiter( - raw_channel, - raw_threshold, - raw_attack, - raw_release, - )?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_limiter( + raw_channel, + raw_threshold, + raw_attack, + raw_release, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1826,8 +1793,12 @@ impl DSP408 { pub fn get_meter_levels( &mut self, ) -> Result<(types::InputMeters, types::OutputMeters), DSPError> { - match self.mode { - types::DSPMode::Connected => { + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Demo { + return Ok((self.input_meters.clone(), self.output_meters.clone())); + } + let request = commands::build_get_meter_levels(); let resp = self.send_recv(&request)?; @@ -1846,12 +1817,7 @@ impl DSP408 { } } - types::DSPMode::Demo => { - // Return the locally simulated meter values. - Ok((self.input_meters.clone(), self.output_meters.clone())) - } - - types::DSPMode::Disconnected => Err(DSPError::NotConnected), + types::ConnectionStatus::Disconnected => Err(DSPError::NotConnected), } } @@ -1866,34 +1832,35 @@ impl DSP408 { let raw_output_channel = mapper::output_channel_to_raw(output_channel)?; let raw_gain = mapper::matrix_gain_db_to_raw(gain)?; - match self.mode { - types::DSPMode::Connected => { - let request = - commands::build_matrix_gain(raw_input_channel, raw_output_channel, raw_gain)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_matrix_gain( + raw_input_channel, + raw_output_channel, + raw_gain, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1919,34 +1886,35 @@ impl DSP408 { let raw_frequency_band = mapper::frequency_value_to_raw(frequency_band)?; let raw_gain = mapper::eq_gain_db_to_raw(gain)?; - match self.mode { - types::DSPMode::Connected => { - let request = - commands::build_set_geq_band(raw_input_channel, raw_frequency_band, raw_gain)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_geq_band( + raw_input_channel, + raw_frequency_band, + raw_gain, + )?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } @@ -1972,33 +1940,31 @@ impl DSP408 { ) -> Result { let raw_input_channel = mapper::input_channel_to_raw(input_channel)?; - match self.mode { - types::DSPMode::Connected => { - let request = commands::build_set_geq_bypass(raw_input_channel, bypass as u8)?; + match self.state.connection { + types::ConnectionStatus::Connected => { + if self.mode == types::DSPMode::Normal { + let request = commands::build_set_geq_bypass(raw_input_channel, bypass as u8)?; - let resp = self.send_recv(&request)?; + let resp = self.send_recv(&request)?; - match resp { - types::DeviceResponseType::Acknowledgement(ack) => { - if !ack.success { - return Ok(false); + match resp { + types::DeviceResponseType::Acknowledgement(ack) => { + if !ack.success { + return Ok(false); + } } - } - other => { - return Err(DSPError::UnexpectedResponse(format!( - "Expected Acknowledgement, got {:?}", - other - ))); + other => { + return Err(DSPError::UnexpectedResponse(format!( + "Expected Acknowledgement, got {:?}", + other + ))); + } } } } - types::DSPMode::Demo => { - // No hardware request. - } - - types::DSPMode::Disconnected => { + types::ConnectionStatus::Disconnected => { return Err(DSPError::NotConnected); } } diff --git a/src/dsp408/default.rs b/src/dsp408/default.rs index 04a2c57..de6bc69 100644 --- a/src/dsp408/default.rs +++ b/src/dsp408/default.rs @@ -1,6 +1,8 @@ use std::collections::HashMap; use strum::IntoEnumIterator; +use crate::dsp408::types; + use super::types::{ Compressor, Crossover, CrossoverFilter, CrossoverFilters, DSPConfigState, DSPState, DelayUnit, DeviceFlags, DiscreteFrequency, Gate, GraphicEQ, InputChannel, InputChannelState, InputMeters, @@ -23,7 +25,7 @@ pub fn default_dsp_state() -> DSPState { current_config: default_config(), - mode: super::types::DSPMode::Disconnected, + connection: types::ConnectionStatus::Disconnected, } } diff --git a/src/dsp408/types.rs b/src/dsp408/types.rs index 6f035da..fc4aed4 100644 --- a/src/dsp408/types.rs +++ b/src/dsp408/types.rs @@ -398,12 +398,14 @@ impl DSPConfigState { } } +#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum DSPMode { Demo, Normal, } +#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ConnectionStatus { Connected,