From 7e89201c6296583336dc201d322a5912292545c7 Mon Sep 17 00:00:00 2001 From: ozpv <39195175+ozpv@users.noreply.github.com> Date: Wed, 20 May 2026 02:54:51 -0500 Subject: simplify things --- src/params.rs | 298 +++++++++++++++++++++++----------------------------------- 1 file changed, 116 insertions(+), 182 deletions(-) (limited to 'src/params.rs') diff --git a/src/params.rs b/src/params.rs index 605e305..4b57dd6 100644 --- a/src/params.rs +++ b/src/params.rs @@ -1,5 +1,3 @@ -//! Contains all types and implementations related to parameter management. - use crate::{RetainPluginMainThread, window_size::WindowSize, window_type::WindowType}; use clack_extensions::{ params::{ @@ -21,18 +19,14 @@ use std::{ sync::atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering}, }; -/// The default value of the order parameter. +/// The default values of the parameters. const DEFAULT_ORDER: usize = 1; pub const DEFAULT_WINDOW_SIZE: WindowSize = WindowSize::Size4096; pub const DEFAULT_WINDOW_TYPE: WindowType = WindowType::Hann; const DEFAULT_COMPLEMENT: bool = false; -/// A struct that manages the parameters for our plugin. -/// -/// This struct will be used both by the [`RetainPluginMainThread`] (which the host will use -/// to query the value of our parameters), and by the [`RetainPluginAudioProcessor`], which will -/// actually modulate the audio samples. -pub struct RetainParamsShared { +/// A struct that manages the parameters for the plugin. +pub struct RetainParams { /// The current value of the order parameter. order: AtomicUsize, /// Window size of FFT @@ -43,12 +37,12 @@ pub struct RetainParamsShared { complement: AtomicBool, } -impl RetainParamsShared { +impl RetainParams { /// The unique identifier for the order parameter. pub const PARAM_ORDER_ID: ClapId = ClapId::new(1); pub const PARAM_WINDOW_SIZE_ID: ClapId = ClapId::new(2); pub const PARAM_WINDOW_TYPE_ID: ClapId = ClapId::new(3); - pub const PARAM_COMPLEMENT_ID: ClapId = ClapId::new(3); + pub const PARAM_COMPLEMENT_ID: ClapId = ClapId::new(4); /// Initializes the shared parameter value. pub fn new() -> Self { @@ -59,157 +53,85 @@ impl RetainParamsShared { complement: AtomicBool::new(DEFAULT_COMPLEMENT), } } -} - -/// The local-side of parameter state. -/// -/// This state is local to the current thread (whether it is the main-thread, the UI or the audio -/// thread), it is not shared directly with the others. -/// -/// This allows us to both check for differences, and to only update parameter state when we want -/// to. -pub struct RetainParamsLocal { - /// The local value of the order parameter. - order: usize, - /// The local value of the window size paramter. - window_size: usize, - /// The local value of the type of window function parameter. - window_type: WindowType, - /// The local value of the complement parameter. - complement: bool, -} - -impl RetainParamsLocal { - /// Initializes a new local state from the current shared state. - pub fn new(shared: &RetainParamsShared) -> Self { - Self { - order: shared.order.load(Ordering::Relaxed), - window_size: shared.window_size.load(Ordering::Relaxed), - window_type: WindowType::from_byte(shared.window_type.load(Ordering::Relaxed)), - complement: shared.complement.load(Ordering::Relaxed), - } - } - /// Returns the current local order value. + /// Returns the current order value. #[inline] pub fn get_order(&self) -> usize { - self.order + self.order.load(Ordering::SeqCst) } - /// Sets the current local order to `value`. + /// Sets the current order to `value`. /// - /// It is clamped to the range `0..=100_000`. + /// It is clamped to the range `0..=32_768`. #[inline] - pub fn set_order(&mut self, value: usize) { - self.order = value; + pub fn set_order(&self, value: usize) { + self.order.store(value.clamp(0, 32768), Ordering::SeqCst); } /// Returns the current window size value. #[inline] - pub fn get_window_size(&self) -> usize { - self.window_size + pub fn get_window_size(&self) -> WindowSize { + self.window_size.load(Ordering::SeqCst).into() } /// Sets the current local window size to `value`. #[inline] - pub fn set_window_size(&mut self, value: usize) { - self.window_size = value; + pub fn set_window_size(&self, value: WindowSize) { + self.window_size.store(value.inner(), Ordering::SeqCst); } /// Returns the current local window type. #[inline] - pub fn get_window_type(&self) -> &WindowType { - &self.window_type + pub fn get_window_type(&self) -> WindowType { + self.window_type.load(Ordering::SeqCst).into() } /// Sets the current local window type from `bits`. #[inline] - pub fn set_window_type_from_byte(&mut self, bits: u8) { - self.window_type = WindowType::from_byte(bits); + pub fn set_window_type(&self, window_type: WindowType) { + self.window_type + .store(window_type.as_byte(), Ordering::SeqCst); } /// Returns the current local complement. #[inline] pub fn get_complement(&self) -> bool { - self.complement + self.complement.load(Ordering::SeqCst) } /// Sets the current local complement to `value`. #[inline] - pub fn set_complement(&mut self, value: bool) { - self.complement = value; - } - - /// Fetch updates from the `shared` state. - /// - /// If any of the parameters have been updated, this returns `true`. - #[inline] - pub fn fetch_updates(&mut self, shared: &RetainParamsShared) -> bool { - let latest_order = shared.order.load(Ordering::Relaxed); - let latest_window_size = shared.window_size.load(Ordering::Relaxed); - let latest_window_type = WindowType::from_byte(shared.window_type.load(Ordering::Relaxed)); - let latest_complement = shared.complement.load(Ordering::Relaxed); - - if latest_order != self.order - || latest_window_size != self.order - || latest_window_type != self.window_type - || latest_complement != self.complement - { - self.order = latest_order; - self.window_size = latest_window_size; - self.window_type = latest_window_type; - self.complement = latest_complement; - - true - } else { - false - } - } - - /// Pushes the local parameter values to the `shared` state. - /// - /// If the values were different and an actual update occurred, this returns `true`. - #[inline] - pub fn push_updates(&self, shared: &RetainParamsShared) -> bool { - let previous_order = shared.order.swap(self.order, Ordering::Relaxed); - let previous_window_size = shared.window_size.swap(self.window_size, Ordering::Relaxed); - let previous_window_type = shared - .window_type - .swap(self.window_type.as_byte(), Ordering::Relaxed); - let previous_complement = shared.complement.swap(self.complement, Ordering::Relaxed); - - previous_order != self.order - || previous_window_size != self.window_size - || previous_window_type != self.window_type.as_byte() - || previous_complement != self.complement + pub fn set_complement(&self, value: bool) { + self.complement.store(value, Ordering::SeqCst); } /// Handles incoming events. /// /// If the given event is a matching parameter change event, the order parameter will be /// updated accordingly. - pub fn handle_event(&mut self, event: &UnknownEvent) { + pub fn handle_event(&self, event: &UnknownEvent) { if let Some(CoreEventSpace::ParamValue(event)) = event.as_core_event() { - if event.param_id() == RetainParamsShared::PARAM_ORDER_ID { + if event.param_id() == RetainParams::PARAM_ORDER_ID { self.set_order(event.value() as usize); } - if event.param_id() == RetainParamsShared::PARAM_WINDOW_SIZE_ID { - self.set_window_size(event.value() as usize); + if event.param_id() == RetainParams::PARAM_WINDOW_SIZE_ID { + self.set_window_size((event.value() as usize).into()); } - if event.param_id() == RetainParamsShared::PARAM_WINDOW_TYPE_ID { - self.set_window_type_from_byte(event.value() as u8); + if event.param_id() == RetainParams::PARAM_WINDOW_TYPE_ID { + self.set_window_type((event.value() as u8).into()); } - if event.param_id() == RetainParamsShared::PARAM_COMPLEMENT_ID { + if event.param_id() == RetainParams::PARAM_COMPLEMENT_ID { self.set_complement(event.value() != 0.0); } } } } -/// To save the plugin state (parameter values) using protocol buffers +/// Wrapper that helps save plugin parameters using protocol buffers +/// Updating this will change the schema and break old #[derive(Message)] struct PluginState { #[prost(uint64, tag = "1")] @@ -223,10 +145,10 @@ struct PluginState { } impl PluginState { - fn copied(local_params: &RetainParamsLocal) -> Self { + fn copied(local_params: &RetainParams) -> Self { Self { order: local_params.get_order() as u64, - window_size: local_params.get_window_size() as u32, + window_size: local_params.get_window_size().inner() as u32, window_type: local_params.get_window_type().as_byte() as u32, complement: local_params.get_complement(), } @@ -249,14 +171,12 @@ impl PluginState { } } -/// Implementation of the State extension. +/// To save and load the plugin parameters impl PluginStateImpl for RetainPluginMainThread<'_> { fn save(&mut self, output: &mut OutputStream) -> Result<(), PluginError> { - self.params.fetch_updates(&self.shared.params); - let mut data = vec![]; - let state = PluginState::copied(&self.params); + let state = PluginState::copied(&self.shared.params); state.encode(&mut data)?; @@ -271,13 +191,14 @@ impl PluginStateImpl for RetainPluginMainThread<'_> { let data = PluginState::decode(&data[..])?; - self.params.set_order(data.get_order() as usize); - self.params.set_window_size(data.get_window_size() as usize); - self.params - .set_window_type_from_byte(data.get_window_type_bits()); - self.params.set_complement(data.get_complement()); - - self.params.push_updates(&self.shared.params); + self.shared.params.set_order(data.get_order() as usize); + self.shared + .params + .set_window_size((data.get_window_size() as usize).into()); + self.shared + .params + .set_window_type(data.get_window_type_bits().into()); + self.shared.params.set_complement(data.get_complement()); Ok(()) } @@ -288,92 +209,105 @@ impl PluginMainThreadParams for RetainPluginMainThread<'_> { 4 } + /// `param_index`: The index of the parameter to query. + /// Must be less than the value returned by `count()`. fn get_info(&mut self, param_index: u32, info: &mut ParamInfoWriter) { - if param_index != 0 { + if param_index >= 4 { return; } - info.set(&ParamInfo { - id: RetainParamsShared::PARAM_ORDER_ID, - flags: ParamInfoFlags::IS_AUTOMATABLE | ParamInfoFlags::IS_STEPPED, - cookie: Cookie::default(), - name: b"Order", - module: b"", - min_value: 0.0, - max_value: f64::MAX, - default_value: DEFAULT_ORDER as f64, - }); - - info.set(&ParamInfo { - id: RetainParamsShared::PARAM_WINDOW_SIZE_ID, - flags: ParamInfoFlags::IS_READONLY, - cookie: Cookie::default(), - name: b"Window Size", - module: b"", - min_value: 128.0, - max_value: usize::MAX as f64, - default_value: DEFAULT_WINDOW_SIZE.inner() as f64, - }); - - info.set(&ParamInfo { - id: RetainParamsShared::PARAM_WINDOW_TYPE_ID, - flags: ParamInfoFlags::IS_READONLY, - cookie: Cookie::default(), - name: b"Window Function", - module: b"", - min_value: 0.0, - max_value: 4.0, - default_value: DEFAULT_WINDOW_TYPE.as_byte() as f64, - }); - - info.set(&ParamInfo { - id: RetainParamsShared::PARAM_COMPLEMENT_ID, - flags: ParamInfoFlags::IS_READONLY, - cookie: Cookie::default(), - name: b"Complement", - module: b"", - min_value: 0.0, - max_value: 1.0, - default_value: DEFAULT_COMPLEMENT as u8 as f64, - }); + // cleaner than match is + if param_index == 0 { + info.set(&ParamInfo { + id: RetainParams::PARAM_ORDER_ID, + flags: ParamInfoFlags::IS_AUTOMATABLE | ParamInfoFlags::IS_STEPPED, + cookie: Cookie::default(), + name: b"Order", + module: b"", + min_value: 0.0, + max_value: 32768.0, + default_value: DEFAULT_ORDER as f64, + }); + } + + if param_index == 1 { + info.set(&ParamInfo { + id: RetainParams::PARAM_WINDOW_SIZE_ID, + flags: ParamInfoFlags::IS_READONLY, + cookie: Cookie::default(), + name: b"Window Size", + module: b"", + min_value: 256.0, + max_value: 32768.0, + default_value: DEFAULT_WINDOW_SIZE.inner() as f64, + }); + } + + if param_index == 2 { + info.set(&ParamInfo { + id: RetainParams::PARAM_WINDOW_TYPE_ID, + flags: ParamInfoFlags::IS_READONLY, + cookie: Cookie::default(), + name: b"Window Function", + module: b"", + min_value: 0.0, + max_value: 4.0, + default_value: DEFAULT_WINDOW_TYPE.as_byte() as f64, + }); + } + + if param_index == 3 { + info.set(&ParamInfo { + id: RetainParams::PARAM_COMPLEMENT_ID, + flags: ParamInfoFlags::IS_READONLY, + cookie: Cookie::default(), + name: b"Complement", + module: b"", + min_value: 0.0, + max_value: 1.0, + default_value: DEFAULT_COMPLEMENT as u8 as f64, + }); + } } fn get_value(&mut self, param_id: ClapId) -> Option { match param_id { - RetainParamsShared::PARAM_ORDER_ID => Some(self.params.get_order() as f64), - RetainParamsShared::PARAM_WINDOW_SIZE_ID => Some(self.params.get_window_size() as f64), - RetainParamsShared::PARAM_WINDOW_TYPE_ID => { - Some(self.params.get_window_type().as_byte() as f64) + RetainParams::PARAM_ORDER_ID => Some(self.shared.params.get_order() as f64), + RetainParams::PARAM_WINDOW_SIZE_ID => { + Some(self.shared.params.get_window_size().inner() as f64) + } + RetainParams::PARAM_WINDOW_TYPE_ID => { + Some(self.shared.params.get_window_type().as_byte() as f64) } - RetainParamsShared::PARAM_COMPLEMENT_ID => { - Some(self.params.get_complement() as u8 as f64) + RetainParams::PARAM_COMPLEMENT_ID => { + Some(self.shared.params.get_complement() as u8 as f64) } _ => None, } } - // TODO: update for order fn value_to_text( &mut self, param_id: ClapId, value: f64, writer: &mut ParamDisplayWriter, ) -> std::fmt::Result { - if param_id == RetainParamsShared::PARAM_ORDER_ID { - write!(writer, "{0:.2} %", value * 100.0) + if param_id == RetainParams::PARAM_ORDER_ID { + write!(writer, "{}", value as u64) } else { Err(std::fmt::Error) } } - // TODO: update for order fn text_to_value(&mut self, param_id: ClapId, text: &CStr) -> Option { let text = text.to_str().ok()?; - if param_id == RetainParamsShared::PARAM_ORDER_ID { - let text = text.strip_suffix('%').unwrap_or(text).trim(); - let percentage: f64 = text.parse().ok()?; - Some(percentage / 100.0) + if param_id == RetainParams::PARAM_ORDER_ID { + let max = self.shared.params.get_window_size().inner() as f64; + + let order_value = text.parse::().ok()?; + + Some(order_value.clamp(0.0, max)) } else { None } @@ -385,7 +319,7 @@ impl PluginMainThreadParams for RetainPluginMainThread<'_> { _output_parameter_changes: &mut OutputEvents, ) { for event in input_parameter_changes { - self.params.handle_event(event); + self.shared.params.handle_event(event); } } } -- cgit v1.2.3