diff --git a/plugins/examples/gain/src/lib.rs b/plugins/examples/gain/src/lib.rs index 5926d46a..710a8df1 100644 --- a/plugins/examples/gain/src/lib.rs +++ b/plugins/examples/gain/src/lib.rs @@ -80,7 +80,7 @@ impl Default for GainParams { // `.with_step_size(0.1)` function to get internal rounding. .with_value_to_string(formatters::v2s_f32_gain_to_db(2)) .with_string_to_value(formatters::s2v_f32_gain_to_db()), - // Persisted fields can be intialized like any other fields, and they'll keep their + // Persisted fields can be initialized like any other fields, and they'll keep their // values when restoring the plugin's state. random_data: RwLock::new(Vec::new()), sub_params: SubParams { diff --git a/plugins/spectral_compressor/src/compressor_bank.rs b/plugins/spectral_compressor/src/compressor_bank.rs index c4b4a6a7..b6b71fe3 100644 --- a/plugins/spectral_compressor/src/compressor_bank.rs +++ b/plugins/spectral_compressor/src/compressor_bank.rs @@ -21,7 +21,7 @@ use std::sync::Arc; use crate::SpectralCompressorParams; -// These are the parameter ID prefixes used for the downwards and upwards cmpression parameters. +// These are the parameter ID prefixes used for the downwards and upwards compression parameters. const DOWNWARDS_NAME_PREFIX: &str = "downwards_"; const UPWARDS_NAME_PREFIX: &str = "upwards_"; diff --git a/src/event_loop/linux.rs b/src/event_loop/linux.rs index d68bd468..a8e6bbd6 100644 --- a/src/event_loop/linux.rs +++ b/src/event_loop/linux.rs @@ -53,7 +53,7 @@ where Self { executor: executor.clone(), main_thread_id: thread::current().id(), - // With our drop implementation we guarentee that this thread never outlives this struct + // With our drop implementation we guarantee that this thread never outlives this struct worker_thread: Some( thread::Builder::new() .name(String::from("worker")) @@ -88,7 +88,7 @@ where fn is_main_thread(&self) -> bool { // FIXME: `thread::current()` may allocate the first time it's called, is there a safe - // nonallocating version of this without using huge OS-specific libraries? + // non-allocating version of this without using huge OS-specific libraries? permit_alloc(|| thread::current().id() == self.main_thread_id) } } diff --git a/src/event_loop/windows.rs b/src/event_loop/windows.rs index 5a030e45..12b97f91 100644 --- a/src/event_loop/windows.rs +++ b/src/event_loop/windows.rs @@ -116,8 +116,8 @@ where HWND(0), HMENU(0), HINSTANCE(0), - // NOTE: We're boxing a box here. As mentioend in [PollCallback], we c an't directly - // pass around fat poitners, so we need a normal pointer to a fat pointer to + // NOTE: We're boxing a box here. As mentioned in [PollCallback], we can't directly + // pass around fat pointers, so we need a normal pointer to a fat pointer to // be able to call this and deallocate it later Box::into_raw(Box::new(callback)) as *const c_void, ) @@ -164,7 +164,7 @@ where fn is_main_thread(&self) -> bool { // FIXME: `thread::current()` may allocate the first time it's called, is there a safe - // nonallocating version of this without using huge OS-specific libraries? + // non-allocating version of this without using huge OS-specific libraries? permit_alloc(|| thread::current().id() == self.main_thread_id) } } diff --git a/src/param/boolean.rs b/src/param/boolean.rs index 6107999e..bc20161d 100644 --- a/src/param/boolean.rs +++ b/src/param/boolean.rs @@ -184,7 +184,7 @@ impl ParamMut for BoolParam { fn set_normalized_value(&self, normalized: f32) { // NOTE: The double conversion here is to make sure the state is reproducible. State is // saved and restored using plain values, and the new normalized value will be - // different from `normalized`. This is not necesasry for the modulation as these + // different from `normalized`. This is not necessary for the modulation as these // values are never shown to the host. self.set_plain_value(self.preview_plain(normalized)) } diff --git a/src/param/float.rs b/src/param/float.rs index 9928e6e7..80936e05 100644 --- a/src/param/float.rs +++ b/src/param/float.rs @@ -218,7 +218,7 @@ impl ParamMut for FloatParam { fn set_normalized_value(&self, normalized: f32) { // NOTE: The double conversion here is to make sure the state is reproducible. State is // saved and restored using plain values, and the new normalized value will be - // different from `normalized`. This is not necesasry for the modulation as these + // different from `normalized`. This is not necessary for the modulation as these // values are never shown to the host. self.set_plain_value(self.preview_plain(normalized)) } @@ -294,7 +294,7 @@ impl FloatParam { /// clicks and zipper noises. pub fn with_smoother(mut self, style: SmoothingStyle) -> Self { // Logarithmic smoothing will cause problems if the range goes through zero since then you - // end up multplying by zero + // end up multiplying by zero let goes_through_zero = match (&style, &self.range) { ( SmoothingStyle::Logarithmic(_), diff --git a/src/param/integer.rs b/src/param/integer.rs index cd32dc69..9816a600 100644 --- a/src/param/integer.rs +++ b/src/param/integer.rs @@ -198,7 +198,7 @@ impl ParamMut for IntParam { fn set_normalized_value(&self, normalized: f32) { // NOTE: The double conversion here is to make sure the state is reproducible. State is // saved and restored using plain values, and the new normalized value will be - // different from `normalized`. This is not necesasry for the modulation as these + // different from `normalized`. This is not necessary for the modulation as these // values are never shown to the host. self.set_plain_value(self.preview_plain(normalized)) } @@ -273,7 +273,7 @@ impl IntParam { /// clicks and zipper noises. pub fn with_smoother(mut self, style: SmoothingStyle) -> Self { // Logarithmic smoothing will cause problems if the range goes through zero since then you - // end up multplying by zero + // end up multiplying by zero let goes_through_zero = match (&style, &self.range) { (SmoothingStyle::Logarithmic(_), IntRange::Linear { min, max }) => { *min == 0 || *max == 0 || min.signum() != max.signum() diff --git a/src/param/range.rs b/src/param/range.rs index dc97ca8a..c4abb112 100644 --- a/src/param/range.rs +++ b/src/param/range.rs @@ -86,7 +86,7 @@ impl FloatRange { (scaled_proportion.powf(*factor) * 0.5) + 0.5 } else { // The part below the center gets scaled, inverted (so the range is [0, 1] where - // 0 corresponds to the center proportion and 1 corresponds to the orignal + // 0 corresponds to the center proportion and 1 corresponds to the original // normalized 0 value), skewed, inverted back again, and then scaled back to the // original range let inverted_scaled_proportion = @@ -137,7 +137,7 @@ impl FloatRange { // range up into 100 segments, but if `self.step_size` is set then we'll use that. Ideally // we might want to split the range up into at most 100 segments, falling back to the step // size if the total number of steps would be smaller than that, but since ranges can be - // nonlienar that's a bit difficult to pull off. + // nonlinear that's a bit difficult to pull off. // TODO: At some point, implement the above mentioned step size quantization match self { FloatRange::Linear { min, max } diff --git a/src/param/smoothing.rs b/src/param/smoothing.rs index 24d3e7b4..c53cbf16 100644 --- a/src/param/smoothing.rs +++ b/src/param/smoothing.rs @@ -109,7 +109,7 @@ impl SmoothingStyle { ((target / start) as f64).powf((num_steps as f64).recip()) as f32 } // In this case the step size value is the coefficient the current value will be - // multiplied by, while the target value is multipled by one minus the coefficient. This + // multiplied by, while the target value is multiplied by one minus the coefficient. This // reaches 99.99% of the target value after `num_steps`. The smoother will snap to the // target value after that point. SmoothingStyle::Exponential(_) => 0.0001f64.powf((num_steps as f64).recip()) as f32, @@ -361,7 +361,7 @@ impl Smoother { let target = T::atomic_load(&self.target); // `self.next()` will yield the current value if the parameter is no longer smoothing, but - // it's a bit of a waste to continuesly call that if only the first couple or none of the + // it's a bit of a waste to continuously call that if only the first couple or none of the // values in `block_values` would require smoothing and the rest don't. Instead, we'll just // smooth the values as necessary, and then reuse the target value for the rest of the // block. diff --git a/src/plugin.rs b/src/plugin.rs index 52c2b814..132ae650 100644 --- a/src/plugin.rs +++ b/src/plugin.rs @@ -264,7 +264,7 @@ pub trait Editor: Send + Sync { // callback that deos involve actual GUI operations will still be spooled to the IRunLoop // instance. // TODO: This function should return an `Option` instead. Right now window opening failures are - // always fatal. This would need to be fixed in basevie first. + // always fatal. This would need to be fixed in baseview first. fn spawn( &self, parent: ParentWindowHandle, diff --git a/src/prelude.rs b/src/prelude.rs index dc44726f..286cd89c 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -1,4 +1,4 @@ -// Re-export the macros, derive macros are already re-exported ferom their respectivem odules +// Re-export the macros, derive macros are already re-exported from their respective modules pub use crate::debug::*; pub use crate::nih_export_clap; diff --git a/src/util/window.rs b/src/util/window.rs index 625075f6..adc5817d 100644 --- a/src/util/window.rs +++ b/src/util/window.rs @@ -40,7 +40,7 @@ pub fn hann_in_place(window: &mut [f32]) { let size = window.len(); // We want to scale `[0, size - 1]` to `[0, pi]`. - // XXX: The `sin^2()` version results in weird rounding errors that cause spectral leakeage + // XXX: The `sin^2()` version results in weird rounding errors that cause spectral leakage let scale = (size as f32 - 1.0).recip() * f32::consts::TAU; for (i, sample) in window.iter_mut().enumerate() { let cos = (i as f32 * scale).cos(); diff --git a/src/wrapper/clap/util.rs b/src/wrapper/clap/util.rs index e9ad35f4..b394dad1 100644 --- a/src/wrapper/clap/util.rs +++ b/src/wrapper/clap/util.rs @@ -14,7 +14,7 @@ macro_rules! check_null_ptr { /// The same as [`check_null_ptr!`], but with a custom message. macro_rules! check_null_ptr_msg { ($msg:expr, $ret:expr, $ptr:expr $(, $ptrs:expr)* $(, )?) => { - // Clippy doesn't understand it when we use a unit in our `check_null_ptr!()` maccro, even + // Clippy doesn't understand it when we use a unit in our `check_null_ptr!()` macro, even // if we explicitly pattern match on that unit #[allow(clippy::unused_unit)] if $ptr.is_null() $(|| $ptrs.is_null())* { diff --git a/src/wrapper/clap/wrapper.rs b/src/wrapper/clap/wrapper.rs index 595b801a..1336c91e 100644 --- a/src/wrapper/clap/wrapper.rs +++ b/src/wrapper/clap/wrapper.rs @@ -203,7 +203,7 @@ pub struct Wrapper { clap_plugin_params: clap_plugin_params, host_params: AtomicRefCell>>, - // These fiels are exactly the same as their VST3 wrapper counterparts. + // These fields are exactly the same as their VST3 wrapper counterparts. // /// The keys from `param_map` in a stable order. param_hashes: Vec, @@ -338,7 +338,7 @@ impl EventLoop> for Wrapper

{ unsafe_clap_call! { thread_check=>is_main_thread(&*self.host_callback) } } // FIXME: `thread::current()` may allocate the first time it's called, is there a safe - // nonallocating version of this without using huge OS-specific libraries? + // non-allocating version of this without using huge OS-specific libraries? None => permit_alloc(|| thread::current().id() == self.main_thread_id), } } @@ -394,7 +394,7 @@ impl Wrapper

{ assert!(!host_callback.is_null()); let host_callback = unsafe { ClapPtr::new(host_callback) }; - // This is a mapping from the parameter IDs specified by the plugin to pointers to thsoe + // This is a mapping from the parameter IDs specified by the plugin to pointers to those // parameters. These pointers are assumed to be safe to dereference as long as // `wrapper.plugin` is alive. The plugin API identifiers these parameters by hashes, which // we'll calculate from the string ID specified by the plugin. These parameters should also @@ -831,7 +831,7 @@ impl Wrapper

{ let mut input_events = self.input_events.borrow_mut(); input_events.clear(); - // To achive this, we'll always read one event ahead + // To achieve this, we'll always read one event ahead let num_events = clap_call! { in_=>size(in_) }; if num_events == 0 { return None; @@ -867,7 +867,7 @@ impl Wrapper

{ ); // NOTE: We explicitly did not do this on a block split because that seems a bit excessive. - // When we're performing a block split we're guarenteed that there's still at least one more + // When we're performing a block split we're guaranteed that there's still at least one more // parameter event after the split so this function will still be called. if parameter_values_changed { self.notify_param_values_changed(); @@ -1283,12 +1283,12 @@ impl Wrapper

{ ); // If the parameter supports polyphonic modulation, then the plugin needs to be - // informed that the parmaeter has been monophonicall automated. This allows the + // informed that the parameter has been monophonically automated. This allows the // plugin to update all of its polyphonic modulation values, since polyphonic // modulation acts as an offset to the monophonic value. if let Some(poly_modulation_id) = self.poly_mod_ids_by_hash.get(&event.param_id) { // The modulation offset needs to be normalized to account for modulated - // integer or enum parmaeters + // integer or enum parameters let param_ptr = self.param_by_hash[&event.param_id]; let normalized_value = event.value as f32 / param_ptr.step_count().unwrap_or(1) as f32; @@ -1309,7 +1309,7 @@ impl Wrapper

{ match self.poly_mod_ids_by_hash.get(&event.param_id) { Some(poly_modulation_id) => { // The modulation offset needs to be normalized to account for modulated - // integer or enum parmaeters + // integer or enum parameters let param_ptr = self.param_by_hash[&event.param_id]; let normalized_offset = event.amount as f32 / param_ptr.step_count().unwrap_or(1) as f32; @@ -1652,7 +1652,7 @@ impl Wrapper

{ check_null_ptr!(false, plugin); let wrapper = &*(plugin as *const Self); - // We weren't allowed to query these in the constructor, so we need to do it now intead. + // We weren't allowed to query these in the constructor, so we need to do it now instead. *wrapper.host_gui.borrow_mut() = query_host_extension::(&wrapper.host_callback, CLAP_EXT_GUI); *wrapper.host_latency.borrow_mut() = @@ -1692,7 +1692,7 @@ impl Wrapper

{ process_mode: wrapper.current_process_mode.load(), }; - // Befure initializing the plugin, make sure all smoothers are set the the default values + // Before initializing the plugin, make sure all smoothers are set the the default values for param in wrapper.param_by_hash.values() { param.update_smoother(buffer_config.sample_rate, true); } @@ -1821,7 +1821,7 @@ impl Wrapper

{ let process = &*process; // Before doing anything, clear out any auxiliary outputs since they may contain - // uninitialized data when the host assumes that we'll always write soemthing there + // uninitialized data when the host assumes that we'll always write something there let current_bus_config = wrapper.current_bus_config.load(); let has_main_input = current_bus_config.num_input_channels > 0; let has_main_output = current_bus_config.num_output_channels > 0; @@ -1891,8 +1891,8 @@ impl Wrapper

{ ); // If there are any parameter changes after `block_start` and sample - // accurate automatoin is enabled or the host sends new transport - // inforamtion, then we'll process a new block just after that. Otherwise we can + // accurate automation is enabled or the host sends new transport + // information, then we'll process a new block just after that. Otherwise we can // process all audio until the end of the buffer. match split_result { Some((next_param_change_sample_idx, next_param_change_event_idx)) => { @@ -2932,7 +2932,7 @@ impl Wrapper

{ strlcpy(&mut param_info.module, param_group); // We don't use the actual minimum and maximum values here because that would not scale // with skewed integer ranges. Instead, just treat all parameters as `[0, 1]` normalized - // paramters multiplied by the step size. + // parameters multiplied by the step size. param_info.min_value = 0.0; // Stepped parameters are unnormalized float parameters since there's no separate step // range option diff --git a/src/wrapper/standalone/backend/cpal.rs b/src/wrapper/standalone/backend/cpal.rs index 7f73a4af..12145c5d 100644 --- a/src/wrapper/standalone/backend/cpal.rs +++ b/src/wrapper/standalone/backend/cpal.rs @@ -342,7 +342,7 @@ impl Cpal { move |data, _info| { // Things may have been moved in between callbacks, so these pointers need to be set up - // agian on each invocation + // again on each invocation unsafe { buffer.with_raw_vec(|output_slices| { for (output_slice, channel) in output_slices.iter_mut().zip(channels.iter_mut()) diff --git a/src/wrapper/standalone/backend/jack.rs b/src/wrapper/standalone/backend/jack.rs index d8f63006..69c319ec 100644 --- a/src/wrapper/standalone/backend/jack.rs +++ b/src/wrapper/standalone/backend/jack.rs @@ -119,7 +119,7 @@ impl Backend for Jack { // Unless it is a SysEx message, a JACK MIDI message is always three bytes or // less and is normalized (starts with a status byte and is self-contained). if midi.bytes.len() <= 3 { - // JACK may not pad messages with zeroes, so mesages for things like channel + // JACK may not pad messages with zeroes, so messages for things like channel // pressure may be less than three bytes in length. let mut midi_data = [0u8; 3]; midi_data[..midi.bytes.len()].copy_from_slice(midi.bytes); diff --git a/src/wrapper/standalone/context.rs b/src/wrapper/standalone/context.rs index bb504589..9e6feef8 100644 --- a/src/wrapper/standalone/context.rs +++ b/src/wrapper/standalone/context.rs @@ -60,7 +60,7 @@ impl GuiContext for WrapperGuiContext { } unsafe fn raw_begin_set_parameter(&self, _param: ParamPtr) { - // Since there's no autmoation being recorded here, gestures don't mean anything + // Since there's no automation being recorded here, gestures don't mean anything } unsafe fn raw_set_parameter_normalized(&self, param: ParamPtr, normalized: f32) { diff --git a/src/wrapper/standalone/wrapper.rs b/src/wrapper/standalone/wrapper.rs index 6305740f..5359058a 100644 --- a/src/wrapper/standalone/wrapper.rs +++ b/src/wrapper/standalone/wrapper.rs @@ -217,7 +217,7 @@ impl Wrapper { }); } - // Befure initializing the plugin, make sure all smoothers are set the the default values + // Before initializing the plugin, make sure all smoothers are set the the default values for param in wrapper.known_parameters.iter() { unsafe { param.update_smoother(wrapper.buffer_config.sample_rate, true) }; } @@ -388,7 +388,7 @@ impl Wrapper { move |buffer, transport, input_events, output_events| { // TODO: This process wrapper should actually be in the backends (since the backends // should also not allocate in their audio callbacks), but that's a bit more - // erorr prone + // error prone process_wrapper(|| { if should_terminate.load(Ordering::SeqCst) { return false; diff --git a/src/wrapper/vst3/context.rs b/src/wrapper/vst3/context.rs index 0c829b89..19a62817 100644 --- a/src/wrapper/vst3/context.rs +++ b/src/wrapper/vst3/context.rs @@ -73,8 +73,8 @@ impl GuiContext for WrapperGuiContext

{ // changing in the middle of the process callback, which would be unsound. // FIXME: So this doesn't work for REAPER, because they just silently stop // processing audio when you bypass the plugin. Great. We can add a time - // based heuristic to work aorund this in the meantime. concat!("asfd", "dsaf", stringify!(34)); + // based heuristic to work around this in the meantime. if !self.inner.is_processing.load(Ordering::SeqCst) { self.inner.set_normalized_value_by_hash( *hash, diff --git a/src/wrapper/vst3/inner.rs b/src/wrapper/vst3/inner.rs index 1fa5b70c..f087733f 100644 --- a/src/wrapper/vst3/inner.rs +++ b/src/wrapper/vst3/inner.rs @@ -196,7 +196,7 @@ impl WrapperInner

{ // on `Self::updated_state_sender` let (updated_state_sender, updated_state_receiver) = channel::bounded(0); - // This is a mapping from the parameter IDs specified by the plugin to pointers to thsoe + // This is a mapping from the parameter IDs specified by the plugin to pointers to those // parameters. These pointers are assumed to be safe to dereference as long as // `wrapper.plugin` is alive. The plugin API identifiers these parameters by hashes, which // we'll calculate from the string ID specified by the plugin. These parameters should also @@ -357,7 +357,7 @@ impl WrapperInner

{ } else { // If the editor is open, and the host exposes the `IRunLoop` interface, then we'll run // the task on the host's GUI thread using that interface. Otherwise we'll use the - // regular eent loop. If the editor gets dropped while there's still outstanding work + // regular event loop. If the editor gets dropped while there's still outstanding work // left in the run loop task queue, then those tasks will be posted to the regular event // loop so no work is lost. match &*self.plug_view.read() { @@ -507,7 +507,7 @@ impl MainThreadExecutor for WrapperInner

{ // TODO: When we add GUI resizing and context menus, this should propagate those events to // `IRunLoop` on Linux to keep REAPER happy. That does mean a double spool, but we can // come up with a nicer solution to handle that later (can always add a separate - // function for checking if a to be scheduled task can be handled right ther and + // function for checking if a to be scheduled task can be handled right there and // then). match task { Task::TriggerRestart(flags) => match &*self.component_handler.borrow() { diff --git a/src/wrapper/vst3/view.rs b/src/wrapper/vst3/view.rs index dd825eea..cdb88560 100644 --- a/src/wrapper/vst3/view.rs +++ b/src/wrapper/vst3/view.rs @@ -345,7 +345,7 @@ impl IPlugView for WrapperView

{ } unsafe fn on_wheel(&self, _distance: f32) -> tresult { - // We'll let the plugin use the OS' input mechamisms because not all DAWs (or very few + // We'll let the plugin use the OS' input mechanisms because not all DAWs (or very few // actually) implement these functions kResultOk } @@ -504,7 +504,7 @@ impl IEventHandler for RunLoopEventHandler

{ #[cfg(target_os = "linux")] impl Drop for RunLoopEventHandler

{ fn drop(&mut self) { - // When this object gets dropped and there are still unprocssed tasks left, then we'll + // When this object gets dropped and there are still unprocessed tasks left, then we'll // handle those in the regular event loop so no work gets lost let mut posting_failed = false; while let Some(task) = self.tasks.pop() { @@ -519,7 +519,7 @@ impl Drop for RunLoopEventHandler

{ if posting_failed { nih_debug_assert_failure!( - "Outstanding tasks have been dropped when clsoing the editor as the task queue \ + "Outstanding tasks have been dropped when closing the editor as the task queue \ was full" ); } diff --git a/src/wrapper/vst3/wrapper.rs b/src/wrapper/vst3/wrapper.rs index 0e9fa245..5d81aca8 100644 --- a/src/wrapper/vst3/wrapper.rs +++ b/src/wrapper/vst3/wrapper.rs @@ -73,7 +73,7 @@ impl IPluginBase for Wrapper

{ impl IComponent for Wrapper

{ unsafe fn get_controller_class_id(&self, _tuid: *mut vst3_sys::IID) -> tresult { - // We won't separate the edit controller to keep the implemetnation a bit smaller + // We won't separate the edit controller to keep the implementation a bit smaller kNoInterface } @@ -383,7 +383,7 @@ impl IComponent for Wrapper

{ // custom channel layout overrides we need to initialize here. match (state != 0, self.inner.current_buffer_config.load()) { (true, Some(buffer_config)) => { - // Befure initializing the plugin, make sure all smoothers are set the the default values + // Before initializing the plugin, make sure all smoothers are set the the default values for param in self.inner.param_by_hash.values() { param.update_smoother(buffer_config.sample_rate, true); } @@ -1033,7 +1033,7 @@ impl IAudioProcessor for Wrapper

{ nih_debug_assert!(data.num_samples >= 0); // Before doing anything, clear out any auxiliary outputs since they may contain - // uninitialized data when the host assumes that we'll always write soemthing there + // uninitialized data when the host assumes that we'll always write something there let current_bus_config = self.inner.current_bus_config.load(); let has_main_input = current_bus_config.num_input_channels > 0; // HACK: Bitwig requires VST3 plugins to always have a main output. We'll however still @@ -1238,7 +1238,7 @@ impl IAudioProcessor for Wrapper

{ // NOTE: It's important that this sort is stable, because parameter changes need to be // processed before note events. Otherwise you'll get out of bounds note events // with block splitting when the note event occurs at one index after the end (or - // on the exlusive end index) of the block. + // on the exclusive end index) of the block. process_events.sort_by_key(|event| match event { ProcessEvent::ParameterChange { timing, .. } => *timing, ProcessEvent::NoteEvent { timing, .. } => *timing, @@ -1252,7 +1252,7 @@ impl IAudioProcessor for Wrapper

{ // sorted process event array until we run into for the current sample, and then // process the block between the current sample and the sample containing the next // parameter change, if any. All timings also need to be compensated for this. As - // mentioend above, for this to work correctly parameter changes need to be ordered + // mentioned above, for this to work correctly parameter changes need to be ordered // before note events at the same index. // The extra scope is here to make sure we release the borrow on input_events { @@ -1557,7 +1557,7 @@ impl IAudioProcessor for Wrapper

{ // There's also a ppqPos field, but uh how about no vst3_event.sample_offset = event.timing() as i32 + block_start as i32; - // `voice_id.onwrap_or(|| ...)` triggers + // `voice_id.unwrap_or(|| ...)` triggers // https://github.com/rust-lang/rust-clippy/issues/8522 #[allow(clippy::unnecessary_lazy_evaluations)] match event {