diff --git a/Cargo.lock b/Cargo.lock index f3815db..5c6c6ab 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -346,7 +346,7 @@ dependencies = [ [[package]] name = "maolan-engine" -version = "0.4.20" +version = "0.4.21" dependencies = [ "alsa", "arc-swap", @@ -386,12 +386,11 @@ dependencies = [ [[package]] name = "maolan-plugin-protocol" -version = "0.0.20" +version = "0.0.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0121a96c6d6bcdeb39d3ab7b005b076ea241ad6c5a0e7c644b942aab73f9d9f" +checksum = "37ef01f71e922f81b59f74d42b875e9a251f208a5aca76fbf9d9cff3b788b2fb" dependencies = [ "libc", - "tracing", "windows-sys", ] diff --git a/Cargo.toml b/Cargo.toml index 5115a98..af3d801 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "maolan-engine" -version = "0.4.20" +version = "0.4.21" edition = "2024" description = "Audio engine for the Maolan DAW with audio/MIDI tracks, routing, export, and out-of-process CLAP/VST3/LV2 plugin support" license = "BSD-2-Clause" @@ -24,7 +24,7 @@ tracing = { version = "0.1.44", features = ["release_max_level_debug"] } midly = { version = "0.5.3", optional = true } serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.154" -maolan-plugin-protocol = { version = "0.0.20", optional = true } +maolan-plugin-protocol = { version = "0.0.21", optional = true } uuid = { version = "1.29.0", features = ["v4"] } fearless_simd = { version = "1.2.0", features = ["force_support_fallback"] } fearless_simd_macros = "0.1" diff --git a/src/plugins/clap_proc.rs b/src/plugins/clap_proc.rs index c930e4a..bd15ef4 100644 --- a/src/plugins/clap_proc.rs +++ b/src/plugins/clap_proc.rs @@ -126,11 +126,26 @@ impl ClapProcessor { .unwrap_or_else(|| plugin_id.to_string()) }; - let (actual_audio_in, actual_audio_out, actual_midi_in, actual_midi_out) = unsafe { - let counts = - maolan_plugin_protocol::protocol::read_port_counts_from_scratch(mapping.as_ptr()); + let ( + actual_audio_in, + actual_audio_out, + actual_midi_in, + actual_midi_out, + actual_main_audio_in, + actual_main_audio_out, + ) = unsafe { + let counts = maolan_plugin_protocol::protocol::read_port_counts_with_main_from_scratch( + mapping.as_ptr(), + ); - counts.unwrap_or((input_count as u32, output_count as u32, 0, 0)) + counts.unwrap_or(( + input_count as u32, + output_count as u32, + 0, + 0, + input_count as u32, + output_count as u32, + )) }; let audio_inputs = (0..actual_audio_in as usize) @@ -168,8 +183,8 @@ impl ClapProcessor { buffer_size, audio_inputs: ArcSwap::from_pointee(audio_inputs), audio_outputs: ArcSwap::from_pointee(audio_outputs), - main_audio_inputs: AtomicUsize::new(actual_audio_in as usize), - main_audio_outputs: AtomicUsize::new(actual_audio_out as usize), + main_audio_inputs: AtomicUsize::new(actual_main_audio_in as usize), + main_audio_outputs: AtomicUsize::new(actual_main_audio_out as usize), midi_input_count: actual_midi_in as usize, midi_output_count: actual_midi_out as usize, midi_input_ports, @@ -219,37 +234,44 @@ impl ClapProcessor { } fn refresh_audio_ports_from_scratch(&self, ptr: *mut u8) -> bool { - let Some((audio_in, audio_out, _, _)) = (unsafe { read_port_counts_from_scratch(ptr) }) + let Some((audio_in, audio_out, _, _, main_audio_in, main_audio_out)) = + (unsafe { read_port_counts_with_main_from_scratch(ptr) }) else { return false; }; let audio_in = audio_in as usize; let audio_out = audio_out as usize; + let main_audio_in = main_audio_in as usize; + let main_audio_out = main_audio_out as usize; let mut changed = false; let current_inputs = self.audio_inputs.load_full(); let current_input_len = current_inputs.len(); drop(current_inputs); - if current_input_len != audio_in - || self.main_audio_inputs.load(Ordering::Acquire) != audio_in - { + if current_input_len != audio_in { let mut inputs = self.audio_inputs.load_full().as_ref().clone(); Self::resize_audio_ports(&mut inputs, audio_in, self.buffer_size); self.audio_inputs.store(Arc::new(inputs)); - self.main_audio_inputs.store(audio_in, Ordering::Release); + changed = true; + } + if self.main_audio_inputs.load(Ordering::Acquire) != main_audio_in { + self.main_audio_inputs + .store(main_audio_in, Ordering::Release); changed = true; } let current_outputs = self.audio_outputs.load_full(); let current_output_len = current_outputs.len(); drop(current_outputs); - if current_output_len != audio_out - || self.main_audio_outputs.load(Ordering::Acquire) != audio_out - { + if current_output_len != audio_out { let mut outputs = self.audio_outputs.load_full().as_ref().clone(); Self::resize_audio_ports(&mut outputs, audio_out, self.buffer_size); self.audio_outputs.store(Arc::new(outputs)); - self.main_audio_outputs.store(audio_out, Ordering::Release); + changed = true; + } + if self.main_audio_outputs.load(Ordering::Acquire) != main_audio_out { + self.main_audio_outputs + .store(main_audio_out, Ordering::Release); changed = true; } changed @@ -1430,4 +1452,86 @@ mod tests { peak ); } + + #[cfg_attr( + miri, + ignore = "plugin host integration requires child processes and OS facilities unavailable under Miri" + )] + #[test] + fn track_clap_external_sidechain_keeps_two_main_inputs() { + use crate::track::Track; + + let host_bin = find_host_binary(); + if !host_bin.exists() { + return; + } + let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap(); + let plugin_path = std::path::Path::new(&manifest) + .parent() + .unwrap() + .join("plugins") + .join("target") + .join("debug") + .join("libmaolan_plugins.so"); + if !plugin_path.exists() { + return; + } + + let bundle_dir = + std::env::temp_dir().join(format!("maolan-gate-test-{}", std::process::id())); + std::fs::create_dir_all(&bundle_dir).expect("test bundle directory should be created"); + let bundle = bundle_dir.join("Maolan.clap"); + #[cfg(unix)] + std::os::unix::fs::symlink(&plugin_path, &bundle).expect("test CLAP bundle should link"); + #[cfg(not(unix))] + std::fs::copy(&plugin_path, &bundle).expect("test CLAP bundle should copy"); + + let mut track = Track::new("gate-test".to_string(), 2, 2, 0, 0, 256, 48_000.0); + track + .load_clap_plugin(&format!("{}::rs.maolan.gate", bundle.display()), None) + .expect("Maolan Gate should load"); + let processor = track.clap_plugins[0].processor.clone(); + assert_eq!(processor.audio_inputs().len(), 2); + assert_eq!(processor.main_audio_input_count(), 2); + + let external_sidechain = processor + .parameter_infos() + .into_iter() + .find(|param| param.name == "External Sidechain") + .expect("Gate should expose External Sidechain") + .id; + processor + .set_parameter(external_sidechain, 1.0) + .expect("external sidechain should be enabled"); + + let input_buffers = [vec![0.0; 256], vec![0.0; 256]]; + let inputs = input_buffers.iter().map(Vec::as_slice).collect::>(); + let mut reconfigured = false; + for _ in 0..4 { + let mut output_buffers = [vec![0.0; 256], vec![0.0; 256]]; + let mut outputs = output_buffers + .iter_mut() + .map(Vec::as_mut_slice) + .collect::>(); + processor.process_with_audio_buffers( + 256, + &[], + ClapTransportInfo::default(), + &inputs, + &mut outputs, + ); + reconfigured = track.setup(); + if reconfigured { + break; + } + } + + assert!(reconfigured, "track should refresh Gate audio ports"); + assert_eq!(processor.audio_inputs().len(), 4); + assert_eq!(processor.main_audio_input_count(), 2); + let graph = track.plugin_graph_plugins(false); + assert_eq!(graph[0].audio_inputs, 4); + assert_eq!(graph[0].main_audio_inputs, 2); + std::fs::remove_dir_all(bundle_dir).expect("test bundle directory should be removed"); + } } diff --git a/src/track/process.rs b/src/track/process.rs index 2c1f842..0cf23ee 100644 --- a/src/track/process.rs +++ b/src/track/process.rs @@ -157,6 +157,21 @@ impl TrackData { #[cfg(not(feature = "plugins"))] let reconfigured = false; #[cfg(feature = "plugins")] + for instance in &self.clap_plugins { + instance.processor.run_host_callbacks_main_thread(); + match instance.processor.reconfigure_ports_if_needed() { + Ok(true) => reconfigured = true, + Err(e) => { + tracing::warn!( + "CLAP port reconfiguration failed for '{}': {}", + instance.processor.name(), + e + ); + } + Ok(false) => {} + } + } + #[cfg(feature = "plugins")] for runtime in self.rt.clip_plugin_tracks.values() { for instance in &runtime.clap_plugins { instance.processor.run_host_callbacks_main_thread();