diff --git a/src/bitcrusher/dsp.rs b/src/bitcrusher/dsp.rs new file mode 100644 index 0000000..1badc16 --- /dev/null +++ b/src/bitcrusher/dsp.rs @@ -0,0 +1,154 @@ +#[derive(Debug, Clone, Copy)] +pub struct BitcrusherParams { + pub bit_depth: f32, + pub downsample: f32, + pub drive_db: f32, + pub dry_wet: f32, + pub output_gain_db: f32, +} + +#[derive(Debug, Clone, Copy, Default)] +struct Channel { + held: f32, + remaining: u32, +} + +impl Channel { + fn reset(&mut self) { + *self = Self::default(); + } + + fn process(&mut self, input: f32, levels: f32, downsample: u32, drive: f32) -> f32 { + if self.remaining == 0 { + let driven = (input * drive).clamp(-1.0, 1.0); + self.held = (driven * levels).round() / levels; + self.remaining = downsample - 1; + } else { + self.remaining -= 1; + } + self.held + } +} + +#[derive(Debug, Clone, Default)] +pub struct Bitcrusher { + left: Channel, + right: Channel, +} + +impl Bitcrusher { + pub fn reset(&mut self) { + self.left.reset(); + self.right.reset(); + } + + pub fn process_stereo( + &mut self, + left: &mut [f32], + right: &mut [f32], + params: &BitcrusherParams, + ) { + let levels = quantization_levels(params.bit_depth); + let downsample = params.downsample.round().clamp(1.0, 128.0) as u32; + let drive = db_to_gain(params.drive_db); + let output_gain = db_to_gain(params.output_gain_db); + let mix = params.dry_wet.clamp(0.0, 1.0); + self.left.remaining = self.left.remaining.min(downsample - 1); + self.right.remaining = self.right.remaining.min(downsample - 1); + + for (left, right) in left.iter_mut().zip(right.iter_mut()) { + let dry_left = *left; + let dry_right = *right; + let crushed_left = self.left.process(dry_left, levels, downsample, drive); + let crushed_right = self.right.process(dry_right, levels, downsample, drive); + *left = (crushed_left * mix + dry_left * (1.0 - mix)) * output_gain; + *right = (crushed_right * mix + dry_right * (1.0 - mix)) * output_gain; + } + } + + pub fn process_mono(&mut self, buffer: &mut [f32], params: &BitcrusherParams) { + let levels = quantization_levels(params.bit_depth); + let downsample = params.downsample.round().clamp(1.0, 128.0) as u32; + let drive = db_to_gain(params.drive_db); + let output_gain = db_to_gain(params.output_gain_db); + let mix = params.dry_wet.clamp(0.0, 1.0); + self.left.remaining = self.left.remaining.min(downsample - 1); + + for sample in buffer { + let dry = *sample; + let crushed = self.left.process(dry, levels, downsample, drive); + *sample = (crushed * mix + dry * (1.0 - mix)) * output_gain; + } + } +} + +fn quantization_levels(bit_depth: f32) -> f32 { + 2.0_f32.powf(bit_depth.round().clamp(1.0, 24.0) - 1.0) +} + +fn db_to_gain(db: f32) -> f32 { + 10.0_f32.powf(db * 0.05) +} + +#[cfg(test)] +mod tests { + use super::{Bitcrusher, BitcrusherParams}; + + fn params() -> BitcrusherParams { + BitcrusherParams { + bit_depth: 8.0, + downsample: 1.0, + drive_db: 0.0, + dry_wet: 1.0, + output_gain_db: 0.0, + } + } + + #[test] + fn quantizes_to_selected_bit_depth() { + let mut crusher = Bitcrusher::default(); + let mut params = params(); + params.bit_depth = 2.0; + let mut input = [0.3, -0.3, 0.8, -0.8]; + crusher.process_mono(&mut input, ¶ms); + assert_eq!(input, [0.5, -0.5, 1.0, -1.0]); + } + + #[test] + fn downsampling_holds_each_quantized_sample() { + let mut crusher = Bitcrusher::default(); + let mut params = params(); + params.downsample = 3.0; + let mut input = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]; + crusher.process_mono(&mut input, ¶ms); + let first = input[0]; + assert_eq!(input[1], first); + assert_eq!(input[2], first); + assert_ne!(input[3], first); + assert_eq!(input[4], input[3]); + assert_eq!(input[5], input[3]); + } + + #[test] + fn dry_mix_preserves_input() { + let mut crusher = Bitcrusher::default(); + let mut params = params(); + params.dry_wet = 0.0; + let original = [0.1, -0.2, 0.3, -0.4]; + let mut input = original; + crusher.process_mono(&mut input, ¶ms); + assert_eq!(input, original); + } + + #[test] + fn stereo_channels_hold_independently() { + let mut crusher = Bitcrusher::default(); + let mut params = params(); + params.downsample = 3.0; + let mut left = [0.25, 0.0, 0.0]; + let mut right = [-0.25, 0.0, 0.0]; + crusher.process_stereo(&mut left, &mut right, ¶ms); + assert!(left.iter().all(|sample| *sample > 0.0)); + assert!(right.iter().all(|sample| *sample < 0.0)); + } +} diff --git a/src/bitcrusher/gui.rs b/src/bitcrusher/gui.rs new file mode 100644 index 0000000..7d1ca23 --- /dev/null +++ b/src/bitcrusher/gui.rs @@ -0,0 +1,326 @@ +use std::{ffi::CStr, sync::Arc}; + +use maolan_baseview::iced::{ + Alignment, Element, Length, Task, Theme, + alignment::{Horizontal, Vertical}, + widget::{column, container, row}, +}; +#[cfg(target_os = "macos")] +use maolan_clap::ffi::CLAP_WINDOW_API_COCOA; +#[cfg(target_os = "windows")] +use maolan_clap::ffi::CLAP_WINDOW_API_WIN32; +#[cfg(any(target_os = "linux", target_os = "freebsd"))] +use maolan_clap::ffi::CLAP_WINDOW_API_X11; +use maolan_widgets::knob::Knob; +#[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" +))] +use raw_window_handle::RawWindowHandle; +use raw_window_handle::{HandleError, HasWindowHandle, WindowHandle}; + +use crate::{ + bitcrusher::{ + params::{PARAMS, ParamId}, + plugin::SharedState, + }, + common::preset::{self, PresetProvider, PresetUi}, +}; + +pub const EDITOR_WIDTH: u32 = 640; +pub const EDITOR_HEIGHT: u32 = 210; + +pub fn preferred_api() -> &'static CStr { + #[cfg(target_os = "windows")] + { + CLAP_WINDOW_API_WIN32 + } + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + { + CLAP_WINDOW_API_X11 + } + #[cfg(target_os = "macos")] + { + CLAP_WINDOW_API_COCOA + } +} + +pub fn is_api_supported(api: &CStr, _is_floating: bool) -> bool { + api == preferred_api() +} + +pub enum ParentWindowHandle { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + X11(usize), + #[cfg(target_os = "macos")] + Cocoa(*mut std::ffi::c_void), + #[cfg(target_os = "windows")] + Win32(*mut std::ffi::c_void), +} + +impl HasWindowHandle for ParentWindowHandle { + fn window_handle(&self) -> Result, HandleError> { + match self { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + ParentWindowHandle::X11(window) => { + let handle = raw_window_handle::XlibWindowHandle::new(*window as _); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::Xlib(handle)) }) + } + #[cfg(target_os = "windows")] + ParentWindowHandle::Win32(hwnd) => { + let handle = raw_window_handle::Win32WindowHandle::new( + std::num::NonZeroIsize::new(*hwnd as isize).unwrap(), + ); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::Win32(handle)) }) + } + #[cfg(target_os = "macos")] + ParentWindowHandle::Cocoa(ns_view) => { + let handle = raw_window_handle::AppKitWindowHandle::new( + std::ptr::NonNull::new(*ns_view).expect("null NSView"), + ); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::AppKit(handle)) }) + } + } + } +} + +#[derive(Debug, Clone)] +pub enum Message { + SetParam(ParamId, f32), + ReleaseParam(ParamId), + Preset(preset::Msg), +} + +impl From for Message { + fn from(msg: preset::Msg) -> Self { + Message::Preset(msg) + } +} + +struct State { + shared: Arc, + active_gestures: Vec, + preset_ui: PresetUi, +} + +fn init(shared: Arc) -> (State, Task) { + ( + State { + shared, + active_gestures: vec![false; ParamId::COUNT], + preset_ui: PresetUi::new(SharedState::DIR_NAME), + }, + Task::none(), + ) +} + +fn update(state: &mut State, message: Message) -> Task { + match message { + Message::SetParam(id, value) => { + let index = id.as_index(); + if !state.active_gestures[index] { + state.active_gestures[index] = true; + state.shared.mark_gesture_begin_pending(id); + } + state.shared.set_param_outbound_only(id, value as f64); + } + Message::ReleaseParam(id) => { + let index = id.as_index(); + if state.active_gestures[index] { + state.active_gestures[index] = false; + state.shared.mark_gesture_end_pending(id); + } + } + Message::Preset(msg) => { + preset::update(&mut state.preset_ui, msg, state.shared.as_ref()); + } + } + Task::none() +} + +fn view(state: &State) -> Element<'_, Message> { + let p = |id: ParamId| state.shared.params.get(id) as f32; + let content = column![ + preset::bar(&state.preset_ui), + row![ + knob( + "Bit Depth", + ParamId::BitDepth, + p(ParamId::BitDepth), + "bit", + 1.0, + ), + knob( + "Downsample", + ParamId::Downsample, + p(ParamId::Downsample), + "x", + 1.0, + ), + knob("Drive", ParamId::Drive, p(ParamId::Drive), "dB", 0.1), + knob("Mix", ParamId::DryWet, p(ParamId::DryWet), "%", 0.01), + knob( + "Output", + ParamId::OutputGain, + p(ParamId::OutputGain), + "dB", + 0.1, + ), + ] + .spacing(12) + .align_y(Alignment::Center), + ] + .spacing(24) + .align_x(Alignment::Start); + + container(content) + .padding(24) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Horizontal::Left) + .align_y(Vertical::Top) + .into() +} + +fn theme(_state: &State) -> Theme { + Theme::TokyoNight +} + +fn knob( + label: &'static str, + id: ParamId, + value: f32, + units: &'static str, + step: f32, +) -> Element<'static, Message> { + let def = PARAMS[id.as_index()]; + let value_text = match units { + "dB" => format!("{value:.1} dB"), + "%" => format!("{:.0}%", value * 100.0), + "bit" => format!("{value:.0} bit"), + "x" => format!("{value:.0}x"), + _ => format!("{value:.2}"), + }; + maolan_widgets::knob::knob( + Knob { + label: label.to_string(), + value, + range: def.min as f32..=def.max as f32, + default: def.default as f32, + step, + value_text, + assigned: false, + }, + move |value| Message::SetParam(id, value), + Message::ReleaseParam(id), + ) +} + +fn build_app(shared: Arc) -> impl maolan_baseview::iced::Program { + maolan_baseview::iced::application(move || init(shared.clone()), update, view) + .font(maolan_widgets::iced_fonts::LUCIDE_FONT_BYTES) + .theme(theme) + .run() +} + +pub struct App; + +impl crate::common::gui_bridge::GuiApp for App { + type Parent = ParentWindowHandle; + + fn title() -> String { + String::from("Maolan Bitcrusher") + } + + fn size() -> (u32, u32) { + (EDITOR_WIDTH, EDITOR_HEIGHT) + } + + fn always_redraw() -> bool { + false + } + + fn notify_closed_on_hide() -> bool { + true + } + + fn opens_parented_window() -> bool { + true + } + + fn preferred_api() -> &'static CStr { + preferred_api() + } + + #[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" + ))] + fn parent_from_window( + window: &maolan_clap::ffi::clap_window, + api: &CStr, + ) -> Option { + crate::bitcrusher::gui::parent_from_window(window, api) + } + + fn build_app( + shared: std::sync::Arc, + ) -> impl maolan_baseview::iced::Program { + build_app(shared) + } +} + +pub type GuiBridge = crate::common::gui_bridge::GuiBridge; + +#[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" +))] +pub fn parent_from_window( + window: &maolan_clap::ffi::clap_window, + api: &CStr, +) -> Option { + use maolan_clap::ffi::{CLAP_WINDOW_API_COCOA, CLAP_WINDOW_API_WIN32, CLAP_WINDOW_API_X11}; + if api == CLAP_WINDOW_API_X11 { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + { + Some(ParentWindowHandle::X11(unsafe { + window.clap_window__.x11 as usize + })) + } + #[cfg(not(any(target_os = "linux", target_os = "freebsd")))] + { + None + } + } else if api == CLAP_WINDOW_API_WIN32 { + #[cfg(target_os = "windows")] + { + Some(ParentWindowHandle::Win32(unsafe { + window.clap_window__.win32 + })) + } + #[cfg(not(target_os = "windows"))] + { + None + } + } else if api == CLAP_WINDOW_API_COCOA { + #[cfg(target_os = "macos")] + { + Some(ParentWindowHandle::Cocoa(unsafe { + window.clap_window__.cocoa + })) + } + #[cfg(not(target_os = "macos"))] + { + None + } + } else { + None + } +} diff --git a/src/bitcrusher/mod.rs b/src/bitcrusher/mod.rs new file mode 100644 index 0000000..a21b470 --- /dev/null +++ b/src/bitcrusher/mod.rs @@ -0,0 +1,7 @@ +pub mod dsp; +pub mod gui; +mod params; +mod plugin; +mod state; + +pub use plugin::{clap_create_plugin, descriptor_ptr as clap_descriptor_ptr}; diff --git a/src/bitcrusher/params.rs b/src/bitcrusher/params.rs new file mode 100644 index 0000000..87b38ff --- /dev/null +++ b/src/bitcrusher/params.rs @@ -0,0 +1,68 @@ +use maolan_clap::ffi::{ + CLAP_PARAM_IS_AUTOMATABLE, CLAP_PARAM_IS_STEPPED, CLAP_PARAM_REQUIRES_PROCESS, +}; + +crate::define_params! { + pub enum ParamId { + BitDepth = 0, + Downsample = 1, + Drive = 2, + DryWet = 3, + OutputGain = 4, + } + pub const PARAMS: [ParamDef] = [ + { + id: ParamId::BitDepth, + name: "Bit Depth", + module: "Crusher", + min: 1.0, + max: 24.0, + default: 8.0, + step: 1.0, + flags: STEPPED, + } + { + id: ParamId::Downsample, + name: "Downsample", + module: "Crusher", + min: 1.0, + max: 128.0, + default: 4.0, + step: 1.0, + flags: STEPPED, + } + { + id: ParamId::Drive, + name: "Drive", + module: "Crusher", + min: 0.0, + max: 24.0, + default: 0.0, + step: 0.1, + flags: AUTOMATABLE, + } + { + id: ParamId::DryWet, + name: "Dry/Wet", + module: "Mix", + min: 0.0, + max: 1.0, + default: 1.0, + step: 0.01, + flags: AUTOMATABLE, + } + { + id: ParamId::OutputGain, + name: "Output Gain", + module: "Output", + min: -24.0, + max: 24.0, + default: 0.0, + step: 0.1, + flags: AUTOMATABLE, + } + ]; +} + +const AUTOMATABLE: u32 = CLAP_PARAM_IS_AUTOMATABLE | CLAP_PARAM_REQUIRES_PROCESS; +const STEPPED: u32 = AUTOMATABLE | CLAP_PARAM_IS_STEPPED; diff --git a/src/bitcrusher/plugin.rs b/src/bitcrusher/plugin.rs new file mode 100644 index 0000000..572c67e --- /dev/null +++ b/src/bitcrusher/plugin.rs @@ -0,0 +1,285 @@ +use std::ffi::{CStr, c_char, c_void}; + +use maolan_clap::{ + ffi::{ + CLAP_EXT_AUDIO_PORTS, CLAP_EXT_GUI, CLAP_EXT_PARAMS, CLAP_EXT_STATE, CLAP_EXT_TAIL, + CLAP_PLUGIN_FEATURE_AUDIO_EFFECT, CLAP_PLUGIN_FEATURE_DISTORTION, CLAP_PLUGIN_FEATURE_MONO, + CLAP_PLUGIN_FEATURE_STEREO, CLAP_PROCESS_CONTINUE, CLAP_VERSION, clap_host, clap_plugin, + clap_plugin_descriptor, clap_process_status, + }, + process::Process, +}; + +use crate::bitcrusher::{ + dsp::{Bitcrusher, BitcrusherParams}, + gui::GuiBridge, + params::{PARAMS, ParamId, sanitize_param_value}, + state::PluginState, +}; +use crate::common::clap_harness::{ + DescriptorMeta, ParamSharedState, ParamSpec, PortConfig, Processor, StateHooks, +}; +use crate::common::{apply_param_events, emit_pending_param_events_to_host}; +use crate::{ + clap_audio_ports_ext, clap_create_fn, clap_descriptor, clap_gui_ext, clap_params_ext, + clap_state_ext, clap_tail_ext, mono_pair, +}; + +const PLUGIN_ID: &[u8] = b"rs.maolan.bitcrusher\0"; +const PLUGIN_NAME: &[u8] = b"Maolan Bitcrusher\0"; +const PLUGIN_VENDOR: &[u8] = b"Maolan\0"; +const PLUGIN_URL: &[u8] = b"\0"; +const PLUGIN_VERSION: &[u8] = b"0.1.0\0"; +const PLUGIN_DESCRIPTION: &[u8] = b"Bit-depth and sample-rate reduction\0"; +const FEATURE_AUDIO_EFFECT: *const c_char = CLAP_PLUGIN_FEATURE_AUDIO_EFFECT.as_ptr(); +const FEATURE_DISTORTION: *const c_char = CLAP_PLUGIN_FEATURE_DISTORTION.as_ptr(); +const FEATURE_MONO: *const c_char = CLAP_PLUGIN_FEATURE_MONO.as_ptr(); +const FEATURE_STEREO: *const c_char = CLAP_PLUGIN_FEATURE_STEREO.as_ptr(); +const FEATURE_PTRS: &[*const c_char] = &[ + FEATURE_AUDIO_EFFECT, + FEATURE_DISTORTION, + FEATURE_MONO, + FEATURE_STEREO, + std::ptr::null(), +]; + +static META: DescriptorMeta = DescriptorMeta { + id: PLUGIN_ID, + name: PLUGIN_NAME, + vendor: PLUGIN_VENDOR, + url: PLUGIN_URL, + version: PLUGIN_VERSION, + description: PLUGIN_DESCRIPTION, + features: FEATURE_PTRS, +}; + +clap_descriptor!(META); + +pub type SharedState = ParamSharedState; + +impl ParamSharedState { + pub fn bump_params_version(&self) {} +} + +crate::impl_param_presets!( + SharedState, + ParamId, + "bitcrusher", + "maolan-bitcrusher-preset" +); + +impl ParamSpec for ParamId { + fn param_defs() -> &'static [crate::common::clap_harness::ParamDef] { + &PARAMS + } + + fn param_text(id: Self, value: f64) -> String { + param_text(id, value) + } + + fn parse_param_text(id: Self, text: &str) -> Option { + parse_param_text(id, text) + } +} + +struct AudioProcessor { + dsp: Bitcrusher, + temp_left: Vec, + temp_right: Vec, +} + +impl AudioProcessor { + fn new(max_frames: u32) -> Self { + Self { + dsp: Bitcrusher::default(), + temp_left: vec![0.0; max_frames as usize], + temp_right: vec![0.0; max_frames as usize], + } + } + + fn reset(&mut self) { + self.dsp.reset(); + } + + fn process(&mut self, shared: &SharedState, process: &mut Process) -> clap_process_status { + apply_param_events(shared, &process.in_events(), sanitize_param_value); + { + let mut out_events = process.out_events(); + emit_pending_param_events_to_host(shared, &mut out_events); + } + + let frames = process.frames_count() as usize; + if self.temp_left.len() < frames { + self.temp_left.resize(frames, 0.0); + self.temp_right.resize(frames, 0.0); + } + + let params = BitcrusherParams { + bit_depth: shared.params.get(ParamId::BitDepth) as f32, + downsample: shared.params.get(ParamId::Downsample) as f32, + drive_db: shared.params.get(ParamId::Drive) as f32, + dry_wet: shared.params.get(ParamId::DryWet) as f32, + output_gain_db: shared.params.get(ParamId::OutputGain) as f32, + }; + let inputs_count = process.audio_inputs_count(); + let outputs_count = process.audio_outputs_count(); + + if inputs_count >= 2 && outputs_count >= 2 { + let input_l = process.audio_inputs(0); + let input_r = process.audio_inputs(1); + self.temp_left[..frames].copy_from_slice(input_l.data32(0)); + self.temp_right[..frames].copy_from_slice(input_r.data32(0)); + self.dsp.process_stereo( + &mut self.temp_left[..frames], + &mut self.temp_right[..frames], + ¶ms, + ); + + let mut output_l = process.audio_outputs(0); + output_l.data32(0)[..frames].copy_from_slice(&self.temp_left[..frames]); + let mut output_r = process.audio_outputs(1); + output_r.data32(0)[..frames].copy_from_slice(&self.temp_right[..frames]); + } else if inputs_count >= 1 && outputs_count >= 1 { + let input = process.audio_inputs(0); + self.temp_left[..frames].copy_from_slice(input.data32(0)); + self.dsp + .process_mono(&mut self.temp_left[..frames], ¶ms); + let mut output = process.audio_outputs(0); + output.data32(0)[..frames].copy_from_slice(&self.temp_left[..frames]); + } + + CLAP_PROCESS_CONTINUE + } +} + +impl Processor for AudioProcessor { + fn new( + _sample_rate: f64, + max_frames: u32, + _bus_data: Option, + ) -> Self { + AudioProcessor::new(max_frames) + } + + fn reset(&mut self) { + AudioProcessor::reset(self); + } + + fn process(&mut self, shared: &SharedState, process: &mut Process) -> clap_process_status { + AudioProcessor::process(self, shared, process) + } +} + +fn param_text(id: ParamId, value: f64) -> String { + match id { + ParamId::BitDepth => format!("{value:.0} bit"), + ParamId::Downsample => format!("{value:.0}x"), + ParamId::Drive | ParamId::OutputGain => format!("{value:.1} dB"), + ParamId::DryWet => format!("{:.0}%", value * 100.0), + } +} + +fn parse_param_text(id: ParamId, text: &str) -> Option { + let text = text.trim(); + match id { + ParamId::BitDepth => text.trim_end_matches("bit").trim().parse().ok(), + ParamId::Downsample => text.trim_end_matches('x').trim().parse().ok(), + ParamId::Drive | ParamId::OutputGain => text + .trim_end_matches("db") + .trim_end_matches("dB") + .trim() + .parse() + .ok(), + ParamId::DryWet => text + .trim_end_matches('%') + .trim() + .parse::() + .ok() + .map(|value| value / 100.0), + } +} + +impl StateHooks for PluginState { + fn save(shared: &SharedState) -> Option> { + PluginState::from_runtime(&shared.params) + .to_bytes(crate::bitcrusher::state::STATE_HEADER_PREFIX) + .ok() + } + + fn load(shared: &SharedState, bytes: &[u8]) -> bool { + let Ok(state) = + PluginState::from_bytes(bytes, crate::bitcrusher::state::STATE_HEADER_PREFIX) + else { + return false; + }; + state.apply(&shared.params); + true + } +} + +clap_audio_ports_ext!(SharedState, AudioProcessor, GuiBridge); +clap_params_ext!(SharedState, AudioProcessor, GuiBridge); +clap_state_ext!(SharedState, AudioProcessor, GuiBridge, PluginState); +clap_tail_ext!(SharedState, AudioProcessor, GuiBridge, 0); +clap_gui_ext!(SharedState, AudioProcessor, GuiBridge); + +unsafe extern "C-unwind" fn plugin_get_extension( + plugin: *const clap_plugin, + id: *const c_char, +) -> *const c_void { + if plugin.is_null() || id.is_null() { + return std::ptr::null(); + } + let id = unsafe { CStr::from_ptr(id) }; + if id == CLAP_EXT_AUDIO_PORTS { + &raw const AUDIO_PORTS_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_PARAMS { + &raw const PARAMS_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_STATE { + &raw const STATE_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_TAIL { + &raw const TAIL_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_GUI { + &raw const GUI_EXT as *const _ as *const c_void + } else { + std::ptr::null() + } +} + +const PORTS: PortConfig = PortConfig { + inputs: mono_pair!("in_l", "in_r"), + outputs: mono_pair!("out_l", "out_r"), +}; + +clap_create_fn!(SharedState, AudioProcessor, GuiBridge, PORTS); + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parameter_text_roundtrips() { + for id in ParamId::all() { + let value = PARAMS[id.as_index()].default; + let text = param_text(id, value); + let parsed = parse_param_text(id, &text).expect("parameter text should parse"); + assert!((parsed - value).abs() < 0.011, "{id:?}: {text}"); + } + } + + #[test] + fn state_roundtrip_preserves_parameters() { + let shared = SharedState::default(); + shared.params.set(ParamId::BitDepth, 5.0); + shared.params.set(ParamId::Downsample, 12.0); + let bytes = PluginState::from_runtime(&shared.params) + .to_bytes(crate::bitcrusher::state::STATE_HEADER_PREFIX) + .expect("state should save"); + let restored = SharedState::default(); + PluginState::from_bytes(&bytes, crate::bitcrusher::state::STATE_HEADER_PREFIX) + .expect("state should load") + .apply(&restored.params); + assert_eq!(restored.params.get(ParamId::BitDepth), 5.0); + assert_eq!(restored.params.get(ParamId::Downsample), 12.0); + } +} diff --git a/src/bitcrusher/state.rs b/src/bitcrusher/state.rs new file mode 100644 index 0000000..da30ed5 --- /dev/null +++ b/src/bitcrusher/state.rs @@ -0,0 +1,5 @@ +use crate::bitcrusher::params::ParamId; + +pub type PluginState = crate::common::json_state::JsonParamState; + +pub const STATE_HEADER_PREFIX: &str = "maolan-bitcrusher-state-v"; diff --git a/src/compressor/dsp/mod.rs b/src/compressor/dsp/mod.rs index a66ee49..f7bbac9 100644 --- a/src/compressor/dsp/mod.rs +++ b/src/compressor/dsp/mod.rs @@ -285,7 +285,11 @@ impl DelayLine { fn process(&mut self, x: f32) -> f32 { let len = self.buffer.len(); let read = (self.write + len - self.delay) % len; - let y = self.buffer[read]; + let y = if self.delay == 0 { + x + } else { + self.buffer[read] + }; self.buffer[self.write] = x; self.write = (self.write + 1) % len; y @@ -637,6 +641,26 @@ impl Compressor { } pub fn process_stereo(&mut self, left: &mut [f32], right: &mut [f32]) { + self.process_stereo_detector(left, right, None, None); + } + + pub fn process_stereo_with_sidechain( + &mut self, + left: &mut [f32], + right: &mut [f32], + sidechain_left: &[f32], + sidechain_right: &[f32], + ) { + self.process_stereo_detector(left, right, Some(sidechain_left), Some(sidechain_right)); + } + + fn process_stereo_detector( + &mut self, + left: &mut [f32], + right: &mut [f32], + sidechain_left: Option<&[f32]>, + sidechain_right: Option<&[f32]>, + ) { if self.bypass { return; } @@ -645,8 +669,14 @@ impl Compressor { for i in 0..frames { let in_l = left[i] * self.input_gain_lin; let in_r = right[i] * self.input_gain_lin; + let detector_l = + sidechain_left.map_or(left[i], |samples| samples[i]) * self.input_gain_lin; + let detector_r = + sidechain_right.map_or(right[i], |samples| samples[i]) * self.input_gain_lin; - let (det_l, det_r) = self.detector_split.split(in_l, in_r, self.band_count); + let (det_l, det_r) = self + .detector_split + .split(detector_l, detector_r, self.band_count); let delayed_l = self.lookahead_l.process(in_l); let delayed_r = self.lookahead_r.process(in_r); @@ -686,14 +716,28 @@ impl Compressor { } pub fn process_mono(&mut self, buffer: &mut [f32]) { + self.process_mono_detector(buffer, None); + } + + pub fn process_mono_with_sidechain(&mut self, buffer: &mut [f32], sidechain: &[f32]) { + self.process_mono_detector(buffer, Some(sidechain)); + } + + fn process_mono_detector(&mut self, buffer: &mut [f32], sidechain: Option<&[f32]>) { if self.bypass { return; } - for sample in buffer.iter_mut() { + for (index, sample) in buffer.iter_mut().enumerate() { let mut l = *sample; let mut r = *sample; - self.process_stereo(std::slice::from_mut(&mut l), std::slice::from_mut(&mut r)); + let sc = sidechain.map_or(*sample, |samples| samples[index]); + self.process_stereo_with_sidechain( + std::slice::from_mut(&mut l), + std::slice::from_mut(&mut r), + std::slice::from_ref(&sc), + std::slice::from_ref(&sc), + ); *sample = 0.5 * (l + r); } } @@ -805,4 +849,32 @@ mod tests { close(compute_gr_db(-6.0, -12.0, 6.0, 2.0, 0.0, 1), 6.0); close(compute_gr_db(-18.0, -12.0, 6.0, 2.0, 0.0, 1), 0.0); } + + #[test] + fn external_sidechain_controls_gain_without_replacing_audio() { + let mut compressor = Compressor::new(48_000.0); + compressor.set_sc_mode(0); + compressor.set_band_threshold_db(0, -40.0); + compressor.set_band_ratio(0, 20.0); + compressor.set_band_range_db(0, -24.0); + compressor.set_band_attack_ms(0, 0.0); + compressor.set_band_release_ms(0, 100.0); + + let mut left = vec![0.25; 128]; + let mut right = vec![0.25; 128]; + let sidechain = vec![1.0; 128]; + compressor.process_stereo_with_sidechain(&mut left, &mut right, &sidechain, &sidechain); + assert!( + left[127] > 0.0, + "sidechain replaced the main audio: {}", + left[127] + ); + assert!( + right[127] > 0.0, + "sidechain replaced the main audio: {}", + right[127] + ); + assert!(left[127] < 0.1, "sidechain did not duck the main audio"); + assert!(right[127] < 0.1, "sidechain did not duck the main audio"); + } } diff --git a/src/compressor/gui.rs b/src/compressor/gui.rs index 2f4a57e..48eefe2 100644 --- a/src/compressor/gui.rs +++ b/src/compressor/gui.rs @@ -557,6 +557,9 @@ fn view(state: &State) -> Element<'_, Message> { let sidechain_controls = row![ text("Sidechain").size(16), + checkbox(b(ParamId::ExternalSidechain)) + .label("External") + .on_toggle(|v| Message::SetBoolParam(ParamId::ExternalSidechain, v)), maolan_baseview::iced::widget::radio("Peak", 0u8, Some(sc_mode as u8), Message::SetScMode), maolan_baseview::iced::widget::radio("RMS", 1u8, Some(sc_mode as u8), Message::SetScMode), checkbox(b(ParamId::Bypass)) diff --git a/src/compressor/params.rs b/src/compressor/params.rs index 6574266..83cc1bc 100644 --- a/src/compressor/params.rs +++ b/src/compressor/params.rs @@ -64,6 +64,7 @@ crate::define_params! { B6Knee = 56, B6Makeup = 57, B6Range = 58, + ExternalSidechain = 59, } pub const PARAMS: [ParamDef] = [ { @@ -656,6 +657,16 @@ crate::define_params! { step: 0.1, flags: AUTOMATABLE, } + { + id: ParamId::ExternalSidechain, + name: "External Sidechain", + module: "Sidechain", + min: 0.0, + max: 1.0, + default: 0.0, + step: 1.0, + flags: BOOL_FLAGS, + } ]; } diff --git a/src/compressor/plugin.rs b/src/compressor/plugin.rs index 78fa12c..a1c03cf 100644 --- a/src/compressor/plugin.rs +++ b/src/compressor/plugin.rs @@ -155,7 +155,7 @@ impl crate::common::SharedStateExt for SharedState { fn set_param_from_host(&self, id: ParamId, value: f64) { self.core.set_param_from_host(id, value); self.bump_params_version(); - if id == ParamId::Channels { + if matches!(id, ParamId::Channels | ParamId::ExternalSidechain) { self.sync_channels_from_params(); self.core.request_audio_ports_rescan(); } @@ -198,7 +198,7 @@ impl SharedState { pub fn set_param_outbound_only(&self, id: ParamId, value: f64) { self.core.set_param_outbound_only(id, value); self.bump_params_version(); - if id == ParamId::Channels { + if matches!(id, ParamId::Channels | ParamId::ExternalSidechain) { self.sync_channels_from_params(); self.core.request_audio_ports_rescan(); } @@ -280,6 +280,8 @@ struct AudioProcessor { compressor: Compressor, temp_left: Vec, temp_right: Vec, + detector_left: Vec, + detector_right: Vec, bus_data: Option, spectrum: StereoSpectrumAnalyzer, spectrum_samples_since_update: usize, @@ -294,6 +296,8 @@ impl AudioProcessor { compressor, temp_left: vec![0.0; max_frames as usize], temp_right: vec![0.0; max_frames as usize], + detector_left: vec![0.0; max_frames as usize], + detector_right: vec![0.0; max_frames as usize], bus_data, spectrum: StereoSpectrumAnalyzer::new(), spectrum_samples_since_update: 0, @@ -468,17 +472,26 @@ impl AudioProcessor { if self.temp_left.len() < frames { self.temp_left.resize(frames, 0.0); self.temp_right.resize(frames, 0.0); + self.detector_left.resize(frames, 0.0); + self.detector_right.resize(frames, 0.0); } let sample_rate = shared.sample_rate(); let spectrum_update_interval_samples = (sample_rate / 10.0).round().max(1.0) as usize; self.spectrum_samples_since_update = self.spectrum_samples_since_update.saturating_add(frames); - let inputs_count = process.audio_inputs_count(); - let outputs_count = process.audio_outputs_count(); + let inputs_count = process.audio_inputs_count() as usize; + let outputs_count = process.audio_outputs_count() as usize; let mut spectrum_ready = false; + let main_channels = if inputs_count >= 2 && outputs_count >= 2 { + 2 + } else if inputs_count >= 1 && outputs_count >= 1 { + 1 + } else { + 0 + }; - if inputs_count >= 2 && outputs_count >= 2 { + if main_channels == 2 { let input_l = process.audio_inputs(0); let input_r = process.audio_inputs(1); self.temp_left[..frames].copy_from_slice(input_l.data32(0)); @@ -488,9 +501,27 @@ impl AudioProcessor { peak_db(&self.temp_right[..frames]), ); - self.compressor.process_stereo( + let external_requested = shared.params.get_bool(ParamId::ExternalSidechain); + let mut external_copied = false; + if external_requested && inputs_count >= 4 { + let sc_l = process.audio_inputs(2); + let sc_r = process.audio_inputs(3); + if sc_l.data32(0).len() >= frames && sc_r.data32(0).len() >= frames { + self.detector_left[..frames].copy_from_slice(&sc_l.data32(0)[..frames]); + self.detector_right[..frames].copy_from_slice(&sc_r.data32(0)[..frames]); + external_copied = true; + } + } + if !external_copied { + self.detector_left[..frames].copy_from_slice(&self.temp_left[..frames]); + self.detector_right[..frames].copy_from_slice(&self.temp_right[..frames]); + } + + self.compressor.process_stereo_with_sidechain( &mut self.temp_left[..frames], &mut self.temp_right[..frames], + &self.detector_left[..frames], + &self.detector_right[..frames], ); shared.set_output_levels_db( peak_db(&self.temp_left[..frames]), @@ -508,11 +539,27 @@ impl AudioProcessor { self.spectrum .push_stereo(&self.temp_left[..frames], &self.temp_right[..frames]); spectrum_ready = true; - } else if inputs_count >= 1 && outputs_count >= 1 { + } else if main_channels == 1 { let input_port = process.audio_inputs(0); self.temp_left[..frames].copy_from_slice(input_port.data32(0)); shared.set_input_levels_db(peak_db(&self.temp_left[..frames]), -90.0); - self.compressor.process_mono(&mut self.temp_left[..frames]); + + let external_requested = shared.params.get_bool(ParamId::ExternalSidechain); + let mut external_copied = false; + if external_requested && inputs_count >= 2 { + let sidechain = process.audio_inputs(1); + if sidechain.data32(0).len() >= frames { + self.detector_left[..frames].copy_from_slice(&sidechain.data32(0)[..frames]); + external_copied = true; + } + } + if !external_copied { + self.detector_left[..frames].copy_from_slice(&self.temp_left[..frames]); + } + self.compressor.process_mono_with_sidechain( + &mut self.temp_left[..frames], + &self.detector_left[..frames], + ); shared.set_output_levels_db(peak_db(&self.temp_left[..frames]), -90.0); let mut output_port = process.audio_outputs(0); @@ -604,6 +651,13 @@ fn param_text(id: ParamId, value: f64) -> String { "Off".into() } } + ParamId::ExternalSidechain => { + if value >= 0.5 { + "External".into() + } else { + "Internal".into() + } + } ParamId::B1Attack | ParamId::B1Release | ParamId::B2Attack @@ -687,6 +741,11 @@ fn parse_param_text(id: ParamId, text: &str) -> Option { "off" | "false" | "0" => Some(0.0), _ => None, }, + ParamId::ExternalSidechain => match text.to_ascii_lowercase().as_str() { + "external" | "on" | "true" | "1" => Some(1.0), + "internal" | "off" | "false" | "0" => Some(0.0), + _ => text.parse().ok(), + }, ParamId::Channels => match text.to_ascii_lowercase().as_str() { "mono" | "1" => Some(1.0), "stereo" | "2" => Some(2.0), @@ -1135,7 +1194,7 @@ fn apply_param_id( dirty.global = true; true } - ParamId::Channels => true, + ParamId::Channels | ParamId::ExternalSidechain => true, } } @@ -1171,13 +1230,24 @@ impl StateHooks for PluginState { return false; }; state.apply(&shared.params); + shared.sync_channels_from_params(); + shared.bump_params_version(); + shared.core.request_audio_ports_rescan(); true } } +fn audio_port_count(is_input: bool, channels: u32, external_sidechain: bool) -> u32 { + if is_input && external_sidechain { + channels * 2 + } else { + channels + } +} + unsafe extern "C-unwind" fn ext_audio_ports_count( plugin: *const clap_plugin, - _is_input: bool, + is_input: bool, ) -> u32 { if plugin.is_null() { return 0; @@ -1185,7 +1255,11 @@ unsafe extern "C-unwind" fn ext_audio_ports_count( let instance = unsafe { crate::common::clap_harness::instance::(plugin) }; - instance.shared.channels.load(Ordering::Acquire) + audio_port_count( + is_input, + instance.shared.channels.load(Ordering::Acquire), + instance.shared.params.get_bool(ParamId::ExternalSidechain), + ) } unsafe extern "C-unwind" fn ext_audio_ports_get( @@ -1201,27 +1275,32 @@ unsafe extern "C-unwind" fn ext_audio_ports_get( crate::common::clap_harness::instance::(plugin) }; let channels = instance.shared.channels.load(Ordering::Acquire); - if index >= channels { + let external = instance.shared.params.get_bool(ParamId::ExternalSidechain); + if index >= audio_port_count(is_input, channels, external) { return false; } let info = unsafe { &mut *info }; info.id = index; - info.flags = maolan_clap::ffi::CLAP_AUDIO_PORT_IS_MAIN; + let is_sidechain = is_input && external && index >= channels; + info.flags = if is_sidechain { + 0 + } else { + maolan_clap::ffi::CLAP_AUDIO_PORT_IS_MAIN + }; info.channel_count = 1; info.port_type = maolan_clap::ffi::CLAP_PORT_MONO.as_ptr(); info.in_place_pair = maolan_clap::ffi::CLAP_INVALID_ID; - let name = if channels == 2 { - match (is_input, index) { - (true, 0) => "in_l", - (true, 1) => "in_r", - (false, 0) => "out_l", - (false, 1) => "out_r", - _ => "", - } - } else if is_input { - "in" - } else { - "out" + let name = match (is_input, channels, index) { + (true, 2, 0) => "in_l", + (true, 2, 1) => "in_r", + (true, 2, 2) => "sc_l", + (true, 2, 3) => "sc_r", + (true, 1, 0) => "in", + (true, 1, 1) => "sc", + (false, 2, 0) => "out_l", + (false, 2, 1) => "out_r", + (false, 1, 0) => "out", + _ => "", }; crate::common::copy_str_to_array(name, &mut info.name); true @@ -1304,4 +1383,32 @@ mod tests { assert_eq!(shared.params.get(ParamId::B1Threshold), 12.0); assert_eq!(shared.params.get(ParamId::B6Threshold), 30.0); } + + #[test] + fn external_sidechain_adds_matching_auxiliary_inputs() { + assert_eq!(audio_port_count(true, 1, false), 1); + assert_eq!(audio_port_count(false, 1, true), 1); + assert_eq!(audio_port_count(true, 1, true), 2); + assert_eq!(audio_port_count(true, 2, true), 4); + assert_eq!(audio_port_count(false, 2, true), 2); + } + + #[test] + fn state_load_refreshes_channels_sidechain_and_dsp_version() { + let saved = SharedState::default(); + saved.params.set(ParamId::Channels, 2.0); + saved.params.set(ParamId::ExternalSidechain, 1.0); + let bytes = PluginState::from_runtime(&saved.params) + .to_bytes(crate::compressor::state::STATE_HEADER_PREFIX) + .expect("state should save"); + + let restored = SharedState::default(); + let previous_version = restored.params_version(); + assert!(>::load( + &restored, &bytes + )); + assert_eq!(restored.channels.load(Ordering::Acquire), 2); + assert!(restored.params.get_bool(ParamId::ExternalSidechain)); + assert!(restored.params_version() > previous_version); + } } diff --git a/src/lib.rs b/src/lib.rs index 0fecb87..0427538 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,6 +11,7 @@ use maolan_clap::ffi::{ clap_plugin_entry, clap_plugin_factory, }; +pub mod bitcrusher; pub mod chorus; pub mod common; pub mod compressor; @@ -32,6 +33,7 @@ pub mod saturator; pub mod simd; pub mod stereo; pub mod synth; +pub mod transient; pub mod tuner; pub mod vocoder; pub mod vumeter; @@ -45,7 +47,7 @@ struct PluginApi { create: CreateFn, } -static PLUGINS: [PluginApi; 23] = [ +static PLUGINS: [PluginApi; 25] = [ PluginApi { descriptor: eq::clap_descriptor_ptr, create: eq::clap_create_plugin, @@ -134,6 +136,14 @@ static PLUGINS: [PluginApi; 23] = [ descriptor: vocoder::clap_descriptor_ptr, create: vocoder::clap_create_plugin, }, + PluginApi { + descriptor: transient::clap_descriptor_ptr, + create: transient::clap_create_plugin, + }, + PluginApi { + descriptor: bitcrusher::clap_descriptor_ptr, + create: bitcrusher::clap_create_plugin, + }, PluginApi { descriptor: random::clap_descriptor_ptr, create: random::clap_create_plugin, @@ -217,3 +227,26 @@ pub static clap_entry: clap_plugin_entry = clap_plugin_entry { deinit: Some(entry_deinit), get_factory: Some(entry_get_factory), }; + +#[cfg(test)] +mod tests { + use super::*; + use std::collections::HashSet; + + #[test] + fn factory_exports_unique_descriptors_including_new_effects() { + assert_eq!(unsafe { factory_get_plugin_count(null()) }, 25); + let mut ids = HashSet::new(); + for index in 0..PLUGINS.len() as u32 { + let descriptor = unsafe { factory_get_plugin_descriptor(null(), index) }; + assert!(!descriptor.is_null()); + let id = unsafe { CStr::from_ptr((*descriptor).id) } + .to_str() + .expect("plugin ID should be UTF-8") + .to_string(); + assert!(ids.insert(id), "duplicate plugin ID at index {index}"); + } + assert!(ids.contains("rs.maolan.transient")); + assert!(ids.contains("rs.maolan.bitcrusher")); + } +} diff --git a/src/transient/dsp.rs b/src/transient/dsp.rs new file mode 100644 index 0000000..9f3cc73 --- /dev/null +++ b/src/transient/dsp.rs @@ -0,0 +1,159 @@ +#[derive(Debug, Clone, Copy)] +pub struct TransientParams { + pub attack_db: f32, + pub sustain_db: f32, + pub attack_ms: f32, + pub release_ms: f32, + pub dry_wet: f32, + pub output_gain_db: f32, +} + +#[derive(Debug, Clone)] +pub struct TransientShaper { + sample_rate: f32, + fast_envelope: f32, + slow_envelope: f32, +} + +impl TransientShaper { + pub fn new(sample_rate: f32) -> Self { + Self { + sample_rate: sample_rate.max(1.0), + fast_envelope: 0.0, + slow_envelope: 0.0, + } + } + + pub fn reset(&mut self) { + self.fast_envelope = 0.0; + self.slow_envelope = 0.0; + } + + pub fn process_stereo( + &mut self, + left: &mut [f32], + right: &mut [f32], + params: &TransientParams, + ) { + let fast_coefficient = time_coefficient(params.attack_ms, self.sample_rate); + let slow_coefficient = time_coefficient(params.release_ms, self.sample_rate); + let output_gain = db_to_gain(params.output_gain_db); + let mix = params.dry_wet.clamp(0.0, 1.0); + + for (left, right) in left.iter_mut().zip(right.iter_mut()) { + let dry_left = *left; + let dry_right = *right; + let level = dry_left.abs().max(dry_right.abs()); + self.fast_envelope += fast_coefficient * (level - self.fast_envelope); + self.slow_envelope += slow_coefficient * (level - self.slow_envelope); + + let fast_db = gain_to_db(self.fast_envelope.max(1.0e-6)); + let slow_db = gain_to_db(self.slow_envelope.max(1.0e-6)); + let transient_db = fast_db - slow_db; + let strength = (transient_db.abs() / 12.0).clamp(0.0, 1.0); + let gain_db = if transient_db >= 0.0 { + params.attack_db * strength + } else { + params.sustain_db * strength + }; + let gain = db_to_gain(gain_db); + + *left = (dry_left * gain * mix + dry_left * (1.0 - mix)) * output_gain; + *right = (dry_right * gain * mix + dry_right * (1.0 - mix)) * output_gain; + } + } + + pub fn process_mono(&mut self, buffer: &mut [f32], params: &TransientParams) { + for sample in buffer { + let mut right = *sample; + self.process_stereo( + std::slice::from_mut(sample), + std::slice::from_mut(&mut right), + params, + ); + } + } +} + +fn time_coefficient(time_ms: f32, sample_rate: f32) -> f32 { + 1.0 - (-1.0 / (time_ms.max(0.01) * 0.001 * sample_rate)).exp() +} + +fn db_to_gain(db: f32) -> f32 { + 10.0_f32.powf(db * 0.05) +} + +fn gain_to_db(gain: f32) -> f32 { + 20.0 * gain.log10() +} + +#[cfg(test)] +mod tests { + use super::{TransientParams, TransientShaper}; + + fn params() -> TransientParams { + TransientParams { + attack_db: 0.0, + sustain_db: 0.0, + attack_ms: 1.0, + release_ms: 100.0, + dry_wet: 1.0, + output_gain_db: 0.0, + } + } + + #[test] + fn neutral_settings_preserve_audio() { + let mut shaper = TransientShaper::new(48_000.0); + let original = [0.0, 0.5, -0.25, 0.1]; + let mut left = original; + let mut right = original; + shaper.process_stereo(&mut left, &mut right, ¶ms()); + assert_eq!(left, original); + assert_eq!(right, original); + } + + #[test] + fn positive_attack_boosts_transient() { + let mut shaper = TransientShaper::new(48_000.0); + let mut params = params(); + params.attack_db = 12.0; + let mut left = [1.0; 16]; + let mut right = [1.0; 16]; + shaper.process_stereo(&mut left, &mut right, ¶ms); + assert!(left[0] > 1.0); + assert!(right[0] > 1.0); + } + + #[test] + fn negative_sustain_reduces_decay() { + let mut shaper = TransientShaper::new(1_000.0); + let mut params = params(); + params.sustain_db = -12.0; + let mut input = vec![1.0; 200]; + input.extend(std::iter::repeat_n(0.25, 100)); + let original = input.clone(); + let mut right = input.clone(); + shaper.process_stereo(&mut input, &mut right, ¶ms); + assert!( + input[250] < original[250], + "processed {}, original {}", + input[250], + original[250] + ); + assert!(right[250] < original[250]); + } + + #[test] + fn stereo_detector_is_linked() { + let mut shaper = TransientShaper::new(48_000.0); + let mut params = params(); + params.attack_db = 12.0; + let mut left = [0.25; 8]; + let mut right = [1.0; 8]; + shaper.process_stereo(&mut left, &mut right, ¶ms); + assert!(left[0] > 0.25); + assert!(right[0] > 1.0); + assert!((left[0] / 0.25 - right[0]).abs() < 1.0e-5); + } +} diff --git a/src/transient/gui.rs b/src/transient/gui.rs new file mode 100644 index 0000000..e0bcd70 --- /dev/null +++ b/src/transient/gui.rs @@ -0,0 +1,325 @@ +use std::{ffi::CStr, sync::Arc}; + +use maolan_baseview::iced::{ + Alignment, Element, Length, Task, Theme, + alignment::{Horizontal, Vertical}, + widget::{column, container, row}, +}; +#[cfg(target_os = "macos")] +use maolan_clap::ffi::CLAP_WINDOW_API_COCOA; +#[cfg(target_os = "windows")] +use maolan_clap::ffi::CLAP_WINDOW_API_WIN32; +#[cfg(any(target_os = "linux", target_os = "freebsd"))] +use maolan_clap::ffi::CLAP_WINDOW_API_X11; +use maolan_widgets::knob::Knob; +#[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" +))] +use raw_window_handle::RawWindowHandle; +use raw_window_handle::{HandleError, HasWindowHandle, WindowHandle}; + +use crate::{ + common::preset::{self, PresetProvider, PresetUi}, + transient::{ + params::{PARAMS, ParamId}, + plugin::SharedState, + }, +}; + +pub const EDITOR_WIDTH: u32 = 640; +pub const EDITOR_HEIGHT: u32 = 210; + +pub fn preferred_api() -> &'static CStr { + #[cfg(target_os = "windows")] + { + CLAP_WINDOW_API_WIN32 + } + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + { + CLAP_WINDOW_API_X11 + } + #[cfg(target_os = "macos")] + { + CLAP_WINDOW_API_COCOA + } +} + +pub fn is_api_supported(api: &CStr, _is_floating: bool) -> bool { + api == preferred_api() +} + +pub enum ParentWindowHandle { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + X11(usize), + #[cfg(target_os = "macos")] + Cocoa(*mut std::ffi::c_void), + #[cfg(target_os = "windows")] + Win32(*mut std::ffi::c_void), +} + +impl HasWindowHandle for ParentWindowHandle { + fn window_handle(&self) -> Result, HandleError> { + match self { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + ParentWindowHandle::X11(window) => { + let handle = raw_window_handle::XlibWindowHandle::new(*window as _); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::Xlib(handle)) }) + } + #[cfg(target_os = "windows")] + ParentWindowHandle::Win32(hwnd) => { + let handle = raw_window_handle::Win32WindowHandle::new( + std::num::NonZeroIsize::new(*hwnd as isize).unwrap(), + ); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::Win32(handle)) }) + } + #[cfg(target_os = "macos")] + ParentWindowHandle::Cocoa(ns_view) => { + let handle = raw_window_handle::AppKitWindowHandle::new( + std::ptr::NonNull::new(*ns_view).expect("null NSView"), + ); + Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::AppKit(handle)) }) + } + } + } +} + +#[derive(Debug, Clone)] +pub enum Message { + SetParam(ParamId, f32), + ReleaseParam(ParamId), + Preset(preset::Msg), +} + +impl From for Message { + fn from(msg: preset::Msg) -> Self { + Message::Preset(msg) + } +} + +struct State { + shared: Arc, + active_gestures: Vec, + preset_ui: PresetUi, +} + +fn init(shared: Arc) -> (State, Task) { + ( + State { + shared, + active_gestures: vec![false; ParamId::COUNT], + preset_ui: PresetUi::new(SharedState::DIR_NAME), + }, + Task::none(), + ) +} + +fn update(state: &mut State, message: Message) -> Task { + match message { + Message::SetParam(id, value) => { + let index = id.as_index(); + if !state.active_gestures[index] { + state.active_gestures[index] = true; + state.shared.mark_gesture_begin_pending(id); + } + state.shared.set_param_outbound_only(id, value as f64); + } + Message::ReleaseParam(id) => { + let index = id.as_index(); + if state.active_gestures[index] { + state.active_gestures[index] = false; + state.shared.mark_gesture_end_pending(id); + } + } + Message::Preset(msg) => { + preset::update(&mut state.preset_ui, msg, state.shared.as_ref()); + } + } + Task::none() +} + +fn view(state: &State) -> Element<'_, Message> { + let p = |id: ParamId| state.shared.params.get(id) as f32; + let content = column![ + preset::bar(&state.preset_ui), + row![ + knob("Attack", ParamId::Attack, p(ParamId::Attack), "dB", 0.1), + knob("Sustain", ParamId::Sustain, p(ParamId::Sustain), "dB", 0.1), + knob("Mix", ParamId::DryWet, p(ParamId::DryWet), "%", 0.01), + knob( + "Attack Time", + ParamId::AttackTime, + p(ParamId::AttackTime), + "ms", + 0.1, + ), + knob( + "Release Time", + ParamId::ReleaseTime, + p(ParamId::ReleaseTime), + "ms", + 1.0, + ), + knob( + "Output", + ParamId::OutputGain, + p(ParamId::OutputGain), + "dB", + 0.1, + ), + ] + .spacing(12) + .align_y(Alignment::Center), + ] + .spacing(24) + .align_x(Alignment::Start); + + container(content) + .padding(24) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Horizontal::Left) + .align_y(Vertical::Top) + .into() +} + +fn theme(_state: &State) -> Theme { + Theme::TokyoNight +} + +fn knob( + label: &'static str, + id: ParamId, + value: f32, + units: &'static str, + step: f32, +) -> Element<'static, Message> { + let def = PARAMS[id.as_index()]; + let value_text = match units { + "dB" | "ms" => format!("{value:.1} {units}"), + "%" => format!("{:.0}%", value * 100.0), + _ => format!("{value:.2}"), + }; + maolan_widgets::knob::knob( + Knob { + label: label.to_string(), + value, + range: def.min as f32..=def.max as f32, + default: def.default as f32, + step, + value_text, + assigned: false, + }, + move |value| Message::SetParam(id, value), + Message::ReleaseParam(id), + ) +} + +fn build_app(shared: Arc) -> impl maolan_baseview::iced::Program { + maolan_baseview::iced::application(move || init(shared.clone()), update, view) + .font(maolan_widgets::iced_fonts::LUCIDE_FONT_BYTES) + .theme(theme) + .run() +} + +pub struct App; + +impl crate::common::gui_bridge::GuiApp for App { + type Parent = ParentWindowHandle; + + fn title() -> String { + String::from("Maolan Transient") + } + + fn size() -> (u32, u32) { + (EDITOR_WIDTH, EDITOR_HEIGHT) + } + + fn always_redraw() -> bool { + false + } + + fn notify_closed_on_hide() -> bool { + true + } + + fn opens_parented_window() -> bool { + true + } + + fn preferred_api() -> &'static CStr { + preferred_api() + } + + #[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" + ))] + fn parent_from_window( + window: &maolan_clap::ffi::clap_window, + api: &CStr, + ) -> Option { + crate::transient::gui::parent_from_window(window, api) + } + + fn build_app( + shared: std::sync::Arc, + ) -> impl maolan_baseview::iced::Program { + build_app(shared) + } +} + +pub type GuiBridge = crate::common::gui_bridge::GuiBridge; + +#[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "linux", + target_os = "freebsd" +))] +pub fn parent_from_window( + window: &maolan_clap::ffi::clap_window, + api: &CStr, +) -> Option { + use maolan_clap::ffi::{CLAP_WINDOW_API_COCOA, CLAP_WINDOW_API_WIN32, CLAP_WINDOW_API_X11}; + if api == CLAP_WINDOW_API_X11 { + #[cfg(any(target_os = "linux", target_os = "freebsd"))] + { + Some(ParentWindowHandle::X11(unsafe { + window.clap_window__.x11 as usize + })) + } + #[cfg(not(any(target_os = "linux", target_os = "freebsd")))] + { + None + } + } else if api == CLAP_WINDOW_API_WIN32 { + #[cfg(target_os = "windows")] + { + Some(ParentWindowHandle::Win32(unsafe { + window.clap_window__.win32 + })) + } + #[cfg(not(target_os = "windows"))] + { + None + } + } else if api == CLAP_WINDOW_API_COCOA { + #[cfg(target_os = "macos")] + { + Some(ParentWindowHandle::Cocoa(unsafe { + window.clap_window__.cocoa + })) + } + #[cfg(not(target_os = "macos"))] + { + None + } + } else { + None + } +} diff --git a/src/transient/mod.rs b/src/transient/mod.rs new file mode 100644 index 0000000..a21b470 --- /dev/null +++ b/src/transient/mod.rs @@ -0,0 +1,7 @@ +pub mod dsp; +pub mod gui; +mod params; +mod plugin; +mod state; + +pub use plugin::{clap_create_plugin, descriptor_ptr as clap_descriptor_ptr}; diff --git a/src/transient/params.rs b/src/transient/params.rs new file mode 100644 index 0000000..f9bc50e --- /dev/null +++ b/src/transient/params.rs @@ -0,0 +1,76 @@ +use maolan_clap::ffi::{CLAP_PARAM_IS_AUTOMATABLE, CLAP_PARAM_REQUIRES_PROCESS}; + +crate::define_params! { + pub enum ParamId { + Attack = 0, + Sustain = 1, + AttackTime = 2, + ReleaseTime = 3, + DryWet = 4, + OutputGain = 5, + } + pub const PARAMS: [ParamDef] = [ + { + id: ParamId::Attack, + name: "Attack", + module: "Transient", + min: -24.0, + max: 24.0, + default: 0.0, + step: 0.1, + flags: AUTOMATABLE, + } + { + id: ParamId::Sustain, + name: "Sustain", + module: "Transient", + min: -24.0, + max: 24.0, + default: 0.0, + step: 0.1, + flags: AUTOMATABLE, + } + { + id: ParamId::AttackTime, + name: "Attack Time", + module: "Detector", + min: 0.1, + max: 20.0, + default: 1.0, + step: 0.1, + flags: AUTOMATABLE, + } + { + id: ParamId::ReleaseTime, + name: "Release Time", + module: "Detector", + min: 10.0, + max: 1000.0, + default: 100.0, + step: 1.0, + flags: AUTOMATABLE, + } + { + id: ParamId::DryWet, + name: "Dry/Wet", + module: "Mix", + min: 0.0, + max: 1.0, + default: 1.0, + step: 0.01, + flags: AUTOMATABLE, + } + { + id: ParamId::OutputGain, + name: "Output Gain", + module: "Output", + min: -24.0, + max: 24.0, + default: 0.0, + step: 0.1, + flags: AUTOMATABLE, + } + ]; +} + +const AUTOMATABLE: u32 = CLAP_PARAM_IS_AUTOMATABLE | CLAP_PARAM_REQUIRES_PROCESS; diff --git a/src/transient/plugin.rs b/src/transient/plugin.rs new file mode 100644 index 0000000..eacdf0a --- /dev/null +++ b/src/transient/plugin.rs @@ -0,0 +1,281 @@ +use std::ffi::{CStr, c_char, c_void}; + +use maolan_clap::{ + ffi::{ + CLAP_EXT_AUDIO_PORTS, CLAP_EXT_GUI, CLAP_EXT_PARAMS, CLAP_EXT_STATE, CLAP_EXT_TAIL, + CLAP_PLUGIN_FEATURE_AUDIO_EFFECT, CLAP_PLUGIN_FEATURE_MONO, CLAP_PLUGIN_FEATURE_STEREO, + CLAP_PLUGIN_FEATURE_TRANSIENT_SHAPER, CLAP_PROCESS_CONTINUE, CLAP_VERSION, clap_host, + clap_plugin, clap_plugin_descriptor, clap_process_status, + }, + process::Process, +}; + +use crate::common::clap_harness::{ + DescriptorMeta, ParamSharedState, ParamSpec, PortConfig, Processor, StateHooks, +}; +use crate::common::{apply_param_events, emit_pending_param_events_to_host}; +use crate::transient::{ + dsp::{TransientParams, TransientShaper}, + gui::GuiBridge, + params::{PARAMS, ParamId, sanitize_param_value}, + state::PluginState, +}; +use crate::{ + clap_audio_ports_ext, clap_create_fn, clap_descriptor, clap_gui_ext, clap_params_ext, + clap_state_ext, clap_tail_ext, mono_pair, +}; + +const PLUGIN_ID: &[u8] = b"rs.maolan.transient\0"; +const PLUGIN_NAME: &[u8] = b"Maolan Transient\0"; +const PLUGIN_VENDOR: &[u8] = b"Maolan\0"; +const PLUGIN_URL: &[u8] = b"\0"; +const PLUGIN_VERSION: &[u8] = b"0.1.0\0"; +const PLUGIN_DESCRIPTION: &[u8] = b"Stereo-linked transient shaper\0"; +const FEATURE_AUDIO_EFFECT: *const c_char = CLAP_PLUGIN_FEATURE_AUDIO_EFFECT.as_ptr(); +const FEATURE_TRANSIENT_SHAPER: *const c_char = CLAP_PLUGIN_FEATURE_TRANSIENT_SHAPER.as_ptr(); +const FEATURE_MONO: *const c_char = CLAP_PLUGIN_FEATURE_MONO.as_ptr(); +const FEATURE_STEREO: *const c_char = CLAP_PLUGIN_FEATURE_STEREO.as_ptr(); +const FEATURE_PTRS: &[*const c_char] = &[ + FEATURE_AUDIO_EFFECT, + FEATURE_TRANSIENT_SHAPER, + FEATURE_MONO, + FEATURE_STEREO, + std::ptr::null(), +]; + +static META: DescriptorMeta = DescriptorMeta { + id: PLUGIN_ID, + name: PLUGIN_NAME, + vendor: PLUGIN_VENDOR, + url: PLUGIN_URL, + version: PLUGIN_VERSION, + description: PLUGIN_DESCRIPTION, + features: FEATURE_PTRS, +}; + +clap_descriptor!(META); + +pub type SharedState = ParamSharedState; + +impl ParamSharedState { + pub fn bump_params_version(&self) {} +} + +crate::impl_param_presets!(SharedState, ParamId, "transient", "maolan-transient-preset"); + +impl ParamSpec for ParamId { + fn param_defs() -> &'static [crate::common::clap_harness::ParamDef] { + &PARAMS + } + + fn param_text(id: Self, value: f64) -> String { + param_text(id, value) + } + + fn parse_param_text(id: Self, text: &str) -> Option { + parse_param_text(id, text) + } +} + +struct AudioProcessor { + dsp: TransientShaper, + temp_left: Vec, + temp_right: Vec, +} + +impl AudioProcessor { + fn new(sample_rate: f64, max_frames: u32) -> Self { + Self { + dsp: TransientShaper::new(sample_rate as f32), + temp_left: vec![0.0; max_frames as usize], + temp_right: vec![0.0; max_frames as usize], + } + } + + fn reset(&mut self) { + self.dsp.reset(); + } + + fn process(&mut self, shared: &SharedState, process: &mut Process) -> clap_process_status { + apply_param_events(shared, &process.in_events(), sanitize_param_value); + { + let mut out_events = process.out_events(); + emit_pending_param_events_to_host(shared, &mut out_events); + } + + let frames = process.frames_count() as usize; + if self.temp_left.len() < frames { + self.temp_left.resize(frames, 0.0); + self.temp_right.resize(frames, 0.0); + } + + let params = TransientParams { + attack_db: shared.params.get(ParamId::Attack) as f32, + sustain_db: shared.params.get(ParamId::Sustain) as f32, + attack_ms: shared.params.get(ParamId::AttackTime) as f32, + release_ms: shared.params.get(ParamId::ReleaseTime) as f32, + dry_wet: shared.params.get(ParamId::DryWet) as f32, + output_gain_db: shared.params.get(ParamId::OutputGain) as f32, + }; + let inputs_count = process.audio_inputs_count(); + let outputs_count = process.audio_outputs_count(); + + if inputs_count >= 2 && outputs_count >= 2 { + let input_l = process.audio_inputs(0); + let input_r = process.audio_inputs(1); + self.temp_left[..frames].copy_from_slice(input_l.data32(0)); + self.temp_right[..frames].copy_from_slice(input_r.data32(0)); + self.dsp.process_stereo( + &mut self.temp_left[..frames], + &mut self.temp_right[..frames], + ¶ms, + ); + + let mut output_l = process.audio_outputs(0); + output_l.data32(0)[..frames].copy_from_slice(&self.temp_left[..frames]); + let mut output_r = process.audio_outputs(1); + output_r.data32(0)[..frames].copy_from_slice(&self.temp_right[..frames]); + } else if inputs_count >= 1 && outputs_count >= 1 { + let input = process.audio_inputs(0); + self.temp_left[..frames].copy_from_slice(input.data32(0)); + self.dsp + .process_mono(&mut self.temp_left[..frames], ¶ms); + let mut output = process.audio_outputs(0); + output.data32(0)[..frames].copy_from_slice(&self.temp_left[..frames]); + } + + CLAP_PROCESS_CONTINUE + } +} + +impl Processor for AudioProcessor { + fn new( + sample_rate: f64, + max_frames: u32, + _bus_data: Option, + ) -> Self { + AudioProcessor::new(sample_rate, max_frames) + } + + fn reset(&mut self) { + AudioProcessor::reset(self); + } + + fn process(&mut self, shared: &SharedState, process: &mut Process) -> clap_process_status { + AudioProcessor::process(self, shared, process) + } +} + +fn param_text(id: ParamId, value: f64) -> String { + match id { + ParamId::Attack | ParamId::Sustain | ParamId::OutputGain => format!("{value:.1} dB"), + ParamId::AttackTime | ParamId::ReleaseTime => format!("{value:.1} ms"), + ParamId::DryWet => format!("{:.0}%", value * 100.0), + } +} + +fn parse_param_text(id: ParamId, text: &str) -> Option { + let text = text.trim(); + match id { + ParamId::Attack | ParamId::Sustain | ParamId::OutputGain => text + .trim_end_matches("db") + .trim_end_matches("dB") + .trim() + .parse() + .ok(), + ParamId::AttackTime | ParamId::ReleaseTime => { + text.trim_end_matches("ms").trim().parse().ok() + } + ParamId::DryWet => text + .trim_end_matches('%') + .trim() + .parse::() + .ok() + .map(|value| value / 100.0), + } +} + +impl StateHooks for PluginState { + fn save(shared: &SharedState) -> Option> { + PluginState::from_runtime(&shared.params) + .to_bytes(crate::transient::state::STATE_HEADER_PREFIX) + .ok() + } + + fn load(shared: &SharedState, bytes: &[u8]) -> bool { + let Ok(state) = + PluginState::from_bytes(bytes, crate::transient::state::STATE_HEADER_PREFIX) + else { + return false; + }; + state.apply(&shared.params); + true + } +} + +clap_audio_ports_ext!(SharedState, AudioProcessor, GuiBridge); +clap_params_ext!(SharedState, AudioProcessor, GuiBridge); +clap_state_ext!(SharedState, AudioProcessor, GuiBridge, PluginState); +clap_tail_ext!(SharedState, AudioProcessor, GuiBridge, 0); +clap_gui_ext!(SharedState, AudioProcessor, GuiBridge); + +unsafe extern "C-unwind" fn plugin_get_extension( + plugin: *const clap_plugin, + id: *const c_char, +) -> *const c_void { + if plugin.is_null() || id.is_null() { + return std::ptr::null(); + } + let id = unsafe { CStr::from_ptr(id) }; + if id == CLAP_EXT_AUDIO_PORTS { + &raw const AUDIO_PORTS_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_PARAMS { + &raw const PARAMS_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_STATE { + &raw const STATE_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_TAIL { + &raw const TAIL_EXT as *const _ as *const c_void + } else if id == CLAP_EXT_GUI { + &raw const GUI_EXT as *const _ as *const c_void + } else { + std::ptr::null() + } +} + +const PORTS: PortConfig = PortConfig { + inputs: mono_pair!("in_l", "in_r"), + outputs: mono_pair!("out_l", "out_r"), +}; + +clap_create_fn!(SharedState, AudioProcessor, GuiBridge, PORTS); + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parameter_text_roundtrips() { + for id in ParamId::all() { + let value = PARAMS[id.as_index()].default; + let text = param_text(id, value); + let parsed = parse_param_text(id, &text).expect("parameter text should parse"); + assert!((parsed - value).abs() < 0.011, "{id:?}: {text}"); + } + } + + #[test] + fn state_roundtrip_preserves_parameters() { + let shared = SharedState::default(); + shared.params.set(ParamId::Attack, 8.0); + shared.params.set(ParamId::Sustain, -6.0); + let bytes = PluginState::from_runtime(&shared.params) + .to_bytes(crate::transient::state::STATE_HEADER_PREFIX) + .expect("state should save"); + let restored = SharedState::default(); + PluginState::from_bytes(&bytes, crate::transient::state::STATE_HEADER_PREFIX) + .expect("state should load") + .apply(&restored.params); + assert_eq!(restored.params.get(ParamId::Attack), 8.0); + assert_eq!(restored.params.get(ParamId::Sustain), -6.0); + } +} diff --git a/src/transient/state.rs b/src/transient/state.rs new file mode 100644 index 0000000..f5e9af8 --- /dev/null +++ b/src/transient/state.rs @@ -0,0 +1,5 @@ +use crate::transient::params::ParamId; + +pub type PluginState = crate::common::json_state::JsonParamState; + +pub const STATE_HEADER_PREFIX: &str = "maolan-transient-state-v";