From f4995abf88cd059276850e3bf59e661a2249549a Mon Sep 17 00:00:00 2001 From: Simon Leiner Date: Thu, 29 Sep 2022 12:28:56 +0200 Subject: [PATCH] Fix typos in documentation --- plugins/examples/gain/src/lib.rs | 2 +- src/buffer.rs | 10 +++++----- src/buffer/blocks.rs | 2 +- src/context.rs | 10 +++++----- src/event_loop/linux.rs | 2 +- src/event_loop/windows.rs | 6 +++--- src/formatters.rs | 4 ++-- src/lib.rs | 6 +++--- src/midi.rs | 6 +++--- src/param.rs | 2 +- src/param/boolean.rs | 4 ++-- src/param/enums.rs | 4 ++-- src/param/float.rs | 8 ++++---- src/param/integer.rs | 6 +++--- src/param/internals.rs | 10 +++++----- src/param/range.rs | 2 +- src/param/smoothing.rs | 6 +++--- src/plugin.rs | 24 ++++++++++++------------ src/util/stft.rs | 6 +++--- src/util/window.rs | 2 +- src/wrapper/clap/factory.rs | 2 +- src/wrapper/clap/util.rs | 2 +- src/wrapper/clap/wrapper.rs | 20 ++++++++++---------- src/wrapper/standalone/wrapper.rs | 2 +- src/wrapper/state.rs | 4 ++-- src/wrapper/vst3/factory.rs | 2 +- src/wrapper/vst3/inner.rs | 16 ++++++++-------- src/wrapper/vst3/note_expressions.rs | 2 +- src/wrapper/vst3/param_units.rs | 4 ++-- src/wrapper/vst3/view.rs | 2 +- 30 files changed, 89 insertions(+), 89 deletions(-) diff --git a/plugins/examples/gain/src/lib.rs b/plugins/examples/gain/src/lib.rs index 8a20996a..5926d46a 100644 --- a/plugins/examples/gain/src/lib.rs +++ b/plugins/examples/gain/src/lib.rs @@ -12,7 +12,7 @@ struct Gain { /// of a parameters struct for multiple identical oscillators/filters/envelopes. #[derive(Params)] struct GainParams { - /// The parameter's ID is used to identify the parameter in the wrappred plugin API. As long as + /// The parameter's ID is used to identify the parameter in the wrapped plugin API. As long as /// these IDs remain constant, you can rename and reorder these fields as you wish. The /// parameters are exposed to the host in the same order they were defined. In this case, this /// gain parameter is stored as linear gain while the values are displayed in decibels. diff --git a/src/buffer.rs b/src/buffer.rs index bfdc06ce..3e1729af 100644 --- a/src/buffer.rs +++ b/src/buffer.rs @@ -17,8 +17,8 @@ pub use samples::{ChannelSamples, ChannelSamplesIter, SamplesIter}; /// this either way. Maybe just get rid of it in favor for raw pointers. #[derive(Default)] pub struct Buffer<'a> { - /// Contains slices for the plugin's outputs. You can't directly create a nested slice form - /// apointer to pointers, so this needs to be preallocated in the setup call and kept around + /// Contains slices for the plugin's outputs. You can't directly create a nested slice from a + /// pointer to pointers, so this needs to be preallocated in the setup call and kept around /// between process calls. And because storing a reference to this means a) that you need a lot /// of lifetime annotations everywhere and b) that at some point you need unsound lifetime casts /// because this `Buffers` either cannot have the same lifetime as the separately stored output @@ -28,7 +28,7 @@ pub struct Buffer<'a> { } impl<'a> Buffer<'a> { - /// Returns the numer of samples in this buffer. + /// Returns the number of samples in this buffer. #[inline] pub fn len(&self) -> usize { if self.output_slices.is_empty() { @@ -38,7 +38,7 @@ impl<'a> Buffer<'a> { } } - /// Returns the numer of channels in this buffer. + /// Returns the number of channels in this buffer. #[inline] pub fn channels(&self) -> usize { self.output_slices.len() @@ -76,7 +76,7 @@ impl<'a> Buffer<'a> { /// Iterate over the buffer in blocks with the specified maximum size. The ideal maximum block /// size depends on the plugin in question, but 64 or 128 samples works for most plugins. Since - /// the buffer's total size may not be cleanly divisble by the maximum size, the returned + /// the buffer's total size may not be cleanly divisible by the maximum size, the returned /// buffers may have any size in `[1, max_block_size]`. This is useful when using algorithms /// that work on entire blocks of audio, like those that would otherwise need to perform /// expensive per-sample branching or that can use per-sample SIMD as opposed to per-channel diff --git a/src/buffer/blocks.rs b/src/buffer/blocks.rs index 0cb6461d..1ef001fc 100644 --- a/src/buffer/blocks.rs +++ b/src/buffer/blocks.rs @@ -131,7 +131,7 @@ impl<'slice, 'sample> Block<'slice, 'sample> { self.current_block_end - self.current_block_start } - /// Returns the numer of channels in this buffer. + /// Returns the number of channels in this buffer. #[inline] pub fn channels(&self) -> usize { unsafe { (*self.buffers).len() } diff --git a/src/context.rs b/src/context.rs index c9163905..825f7d48 100644 --- a/src/context.rs +++ b/src/context.rs @@ -179,7 +179,7 @@ pub struct Transport { /// [`Plugin::initialize()`][crate::prelude::Plugin::initialize()], so if you need this then you /// can also store that value. pub sample_rate: f32, - /// The proejct's tempo in beats per minute. + /// The project's tempo in beats per minute. pub tempo: Option, /// The time signature's numerator. pub time_sig_numerator: Option, @@ -206,15 +206,15 @@ pub struct Transport { /// The loop range in samples, if the loop is active and this information is available. None of /// the plugin API docs mention whether this is exclusive or inclusive, but just assume that the - /// end is exclusive. Can be calulcated from the other loop range information if needed. + /// end is exclusive. Can be calculated from the other loop range information if needed. pub(crate) loop_range_samples: Option<(i64, i64)>, /// The loop range in seconds, if the loop is active and this information is available. None of /// the plugin API docs mention whether this is exclusive or inclusive, but just assume that the - /// end is exclusive. Can be calulcated from the other loop range information if needed. + /// end is exclusive. Can be calculated from the other loop range information if needed. pub(crate) loop_range_seconds: Option<(f64, f64)>, /// The loop range in quarter notes, if the loop is active and this information is available. /// None of the plugin API docs mention whether this is exclusive or inclusive, but just assume - /// that the end is exclusive. Can be calulcated from the other loop range information if + /// that the end is exclusive. Can be calculated from the other loop range information if /// needed. pub(crate) loop_range_beats: Option<(f64, f64)>, } @@ -440,7 +440,7 @@ impl<'a> ParamSetter<'a> { } } - /// Inform the host that you will start automating a parmater. This needs to be called before + /// Inform the host that you will start automating a parameter. This needs to be called before /// calling [`set_parameter()`][Self::set_parameter()] for the specified parameter. pub fn begin_set_parameter(&self, param: &P) { unsafe { self.raw_context.raw_begin_set_parameter(param.as_ptr()) }; diff --git a/src/event_loop/linux.rs b/src/event_loop/linux.rs index 5aaeea6c..d68bd468 100644 --- a/src/event_loop/linux.rs +++ b/src/event_loop/linux.rs @@ -104,7 +104,7 @@ impl Drop for LinuxEventLoop { } } -/// The worker thread used in [`EventLoop`] that executes incmoing tasks on the event loop's +/// The worker thread used in [`EventLoop`] that executes incoming tasks on the event loop's /// executor. fn worker_thread(receiver: channel::Receiver>, executor: Weak) where diff --git a/src/event_loop/windows.rs b/src/event_loop/windows.rs index 714d8d67..5a030e45 100644 --- a/src/event_loop/windows.rs +++ b/src/event_loop/windows.rs @@ -26,10 +26,10 @@ use crate::util::permit_alloc; const NOTIFY_MESSAGE_ID: u32 = WM_USER; /// A type erased function passed to the window so it can poll for events. We can't pass the tasks -/// queue and executor to the window callback sicne the callback wouldn't know what types they are, +/// queue and executor to the window callback since the callback wouldn't know what types they are, /// but we can wrap the polling loop in a closure and pass that instead. /// -/// This needs to be double boxed when passed to the function since fat pointers canont be directly +/// This needs to be double boxed when passed to the function since fat pointers cannot be directly /// casted from a regular pointer. type PollCallback = Box; @@ -45,7 +45,7 @@ pub(crate) struct WindowsEventLoop { main_thread_id: ThreadId, /// An invisible window that we can post a message to when we need to do something on the main - /// thread. The host's message loop will then cause our message to be proceded. + /// thread. The host's message loop will then cause our message to be proceeded. message_window: HWND, /// The unique class for the message window, we'll clean this up together with the window. message_window_class_name: CString, diff --git a/src/formatters.rs b/src/formatters.rs index 2002f3c7..9c021cef 100644 --- a/src/formatters.rs +++ b/src/formatters.rs @@ -1,7 +1,7 @@ //! Convenience functions for formatting and parsing parameter values in various common formats. //! //! Functions prefixed with `v2s_` are meant to be used with the `.value_to_string()` parameter -//! fucntions, while the `s2v_` functions are meant to be used wit the `.string_to_value()`. +//! functions, while the `s2v_` functions are meant to be used wit the `.string_to_value()`. //! functions. Most of these formatters come as a pair. Check each formatter's documentation for any //! additional usage information. @@ -203,7 +203,7 @@ pub fn s2v_i32_note_formatter() -> Arc Option + Send + Sync } /// Display 'Bypassed' or 'Not Bypassed' depending on whether the parameter is true or false. -/// 'Enabled' would have also been a possibilty here, but that could be a bit confusing. +/// 'Enabled' would have also been a possibility here, but that could be a bit confusing. pub fn v2s_bool_bypass() -> Arc String + Send + Sync> { Arc::new(move |value| { if value { diff --git a/src/lib.rs b/src/lib.rs index 30938e40..a031acc9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,7 +11,7 @@ //! debugger is attached, in which case the output is logged to the debug console instead. The //! `NIH_LOG` environment variable controls whether output is logged to STDERR, the Windows debug //! console, or to a file. Check the [`nih_log!()`] macro for more information. -//! - The abovementioned debug module also contains non-fatal debug-assertions macros that are only +//! - The aforementioned debug module also contains non-fatal debug-assertions macros that are only //! evaluated during debug builds. The framework uses these all over the place to check for //! invariants, so it's important to test your plugins using debug builds while developing. //! - Check out the features list in NIH-plug's `Cargo.toml` file for optional features you can @@ -38,7 +38,7 @@ //! calculations or IO at this point. //! 2. The host or the plugin wrapper will call //! [`Plugin::accepts_bus_config()`][prelude::Plugin::accepts_bus_config()] several times with -//! different IO configuratinos to poll whether your plugin supports certain IO configurations. +//! different IO configurations to poll whether your plugin supports certain IO configurations. //! The plugin should not do any work at this point and just reply with boolean whether it //! supports the configuration or not. //! 3. After that, [`Plugin::initialize()`][prelude::Plugin::initialize()] will be called with the @@ -78,7 +78,7 @@ //! out the [`Smoother`][prelude::Smoother] API for more details. //! //! There's a whole lot more to discuss, but once you understand the above you should be able to -//! figure out the rest by reading through the examples and the API documetnation. Good luck! +//! figure out the rest by reading through the examples and the API documentation. Good luck! #![cfg_attr(feature = "docs", feature(doc_auto_cfg))] #![cfg_attr(feature = "simd", feature(portable_simd))] diff --git a/src/midi.rs b/src/midi.rs index 2771b6ab..412d30ed 100644 --- a/src/midi.rs +++ b/src/midi.rs @@ -98,7 +98,7 @@ pub enum NoteEvent { /// monophonic modulation. This is `parameter.value` for unsmoothed parameters, and smoothed /// parameters should use block smoothing so the smoothed values can be reused by multiple /// voices. - /// - If a `PolyModulation` event is emited for the voice, that voice should use the the + /// - If a `PolyModulation` event is emitted for the voice, that voice should use the the /// _normalized offset_ contained within the event to compute the voice's modulated value and /// use that in place of the global value. /// - This value can be obtained by calling `param.preview_plain(param.normalized_value() + @@ -137,9 +137,9 @@ pub enum NoteEvent { normalized_offset: f32, }, /// A notification to inform the plugin that a polyphonically modulated parameter has received a - /// new automation value. This is used in conjuction with the `PolyModulation` event. See that + /// new automation value. This is used in conjunction with the `PolyModulation` event. See that /// event's documentation for more details. The parameter's global value has already been - /// updated when this event is emited. + /// updated when this event is emitted. MonoAutomation { timing: u32, /// The ID that was set for the modulated parameter using the `.with_poly_modulation_id()` diff --git a/src/param.rs b/src/param.rs index e154d2eb..9a96a70d 100644 --- a/src/param.rs +++ b/src/param.rs @@ -103,7 +103,7 @@ pub trait Param: Display { self.preview_normalized(self.default_plain_value()) } - /// Get the number of steps for this paramter, if it is discrete. Used for the host's generic + /// Get the number of steps for this parameter, if it is discrete. Used for the host's generic /// UI. fn step_count(&self) -> Option; diff --git a/src/param/boolean.rs b/src/param/boolean.rs index cd210213..6107999e 100644 --- a/src/param/boolean.rs +++ b/src/param/boolean.rs @@ -21,7 +21,7 @@ pub struct BoolParam { /// from the host has been applied. This will always be the same as `value` for VST3 plugins. unmodulated_normalized_value: AtomicF32, /// A value in `[-1, 1]` indicating the amount of modulation applied to - /// `unmodulated_normalized_`. This needs to be stored separately since the normalied values are + /// `unmodulated_normalized_`. This needs to be stored separately since the normalized values are /// clamped, and this value persists after new automation events. modulation_offset: AtomicF32, /// The field's default value. @@ -286,7 +286,7 @@ impl BoolParam { self } - /// Mark the paramter as non-automatable. This means that the parameter cannot be changed from + /// Mark the parameter as non-automatable. This means that the parameter cannot be changed from /// an automation lane. The parameter can however still be manually changed by the user from /// either the plugin's own GUI or from the host's generic UI. pub fn non_automatable(mut self) -> Self { diff --git a/src/param/enums.rs b/src/param/enums.rs index a5c7ac43..a9534625 100644 --- a/src/param/enums.rs +++ b/src/param/enums.rs @@ -63,7 +63,7 @@ pub trait Enum { /// Get the variant corresponding to the variant with the same index in /// [`variants()`][Self::variants()]. This must always return a value. If the index is out of - /// range, return the first variatn. + /// range, return the first variant. fn from_index(index: usize) -> Self; } @@ -360,7 +360,7 @@ impl EnumParam { self } - /// Mark the paramter as non-automatable. This means that the parameter cannot be changed from + /// Mark the parameter as non-automatable. This means that the parameter cannot be changed from /// an automation lane. The parameter can however still be manually changed by the user from /// either the plugin's own GUI or from the host's generic UI. pub fn non_automatable(mut self) -> Self { diff --git a/src/param/float.rs b/src/param/float.rs index ed477b56..9928e6e7 100644 --- a/src/param/float.rs +++ b/src/param/float.rs @@ -24,7 +24,7 @@ pub struct FloatParam { /// from the host has been applied. This will always be the same as `value` for VST3 plugins. unmodulated_normalized_value: AtomicF32, /// A value in `[-1, 1]` indicating the amount of modulation applied to - /// `unmodulated_normalized_`. This needs to be stored separately since the normalied values are + /// `unmodulated_normalized_`. This needs to be stored separately since the normalized values are /// clamped, and this value persists after new automation events. modulation_offset: AtomicF32, /// The field's default plain, unnormalized value. @@ -39,7 +39,7 @@ pub struct FloatParam { /// the parameter's new **plain** value. This should not do anything expensive as it may be /// called multiple times in rapid succession. /// - /// To use this, you'll probably want to store an `Arc` alongside the parmater in the + /// To use this, you'll probably want to store an `Arc` alongside the parameter in the /// parameters struct, move a clone of that `Arc` into this closure, and then modify that. /// /// TODO: We probably also want to pass the old value to this function. @@ -363,7 +363,7 @@ impl FloatParam { self } - /// Mark the paramter as non-automatable. This means that the parameter cannot be changed from + /// Mark the parameter as non-automatable. This means that the parameter cannot be changed from /// an automation lane. The parameter can however still be manually changed by the user from /// either the plugin's own GUI or from the host's generic UI. pub fn non_automatable(mut self) -> Self { @@ -387,7 +387,7 @@ impl FloatParam { } } -/// Caldculate how many decimals to round to when displaying a floating point value with a specific +/// Calculate how many decimals to round to when displaying a floating point value with a specific /// step size. We'll perform some rounding to ignore spurious extra precision caused by the floating /// point quantization. fn decimals_from_step_size(step_size: f32) -> usize { diff --git a/src/param/integer.rs b/src/param/integer.rs index 29e51d9a..cd32dc69 100644 --- a/src/param/integer.rs +++ b/src/param/integer.rs @@ -24,7 +24,7 @@ pub struct IntParam { /// from the host has been applied. This will always be the same as `value` for VST3 plugins. unmodulated_normalized_value: AtomicF32, /// A value in `[-1, 1]` indicating the amount of modulation applied to - /// `unmodulated_normalized_`. This needs to be stored separately since the normalied values are + /// `unmodulated_normalized_`. This needs to be stored separately since the normalized values are /// clamped, and this value persists after new automation events. modulation_offset: AtomicF32, /// The field's default plain, unnormalized value. @@ -39,7 +39,7 @@ pub struct IntParam { /// the parameter's new **plain** value. This should not do anything expensive as it may be /// called multiple times in rapid succession. /// - /// To use this, you'll probably want to store an `Arc` alongside the parmater in the + /// To use this, you'll probably want to store an `Arc` alongside the parameter in the /// parameters struct, move a clone of that `Arc` into this closure, and then modify that. /// /// TODO: We probably also want to pass the old value to this function. @@ -332,7 +332,7 @@ impl IntParam { self } - /// Mark the paramter as non-automatable. This means that the parameter cannot be changed from + /// Mark the parameter as non-automatable. This means that the parameter cannot be changed from /// an automation lane. The parameter can however still be manually changed by the user from /// either the plugin's own GUI or from the host's generic UI. pub fn non_automatable(mut self) -> Self { diff --git a/src/param/internals.rs b/src/param/internals.rs index 2e688ee5..a31ceace 100644 --- a/src/param/internals.rs +++ b/src/param/internals.rs @@ -39,7 +39,7 @@ pub mod serialize_atomic_cell { /// This trait can be derived on a struct containing [`FloatParam`][super::FloatParam] and other /// parameter fields. When deriving this trait, any of those parameter fields should have the `#[id /// = "stable"]` attribute, where `stable` is an up to 6 character long string (to avoid collisions) -/// that will be used to identify the parameter internall so you can safely move it around and +/// that will be used to identify the parameter internally so you can safely move it around and /// rename the field without breaking compatibility with old presets. /// /// The struct can also contain other fields that should be persisted along with the rest of the @@ -50,7 +50,7 @@ pub mod serialize_atomic_cell { /// And finally when deriving this trait, it is also possible to inherit the parameters from other /// `Params` objects by adding the `#[nested = "Group Name"]` attribute to those fields. These /// groups will be displayed as a tree-like structure if your DAW supports it. Parameter IDs and -/// persisting keys still need to be **unique** when usting nested parameter structs. This currently +/// persisting keys still need to be **unique** when using nested parameter structs. This currently /// has the following caveats: /// /// - Enforcing that parameter IDs and persist keys are unique does not work across nested structs. @@ -71,13 +71,13 @@ pub unsafe trait Params: 'static + Send + Sync { /// exist or you may encounter panics. The derive macro does this for every parameter field /// marked with `#[id = "stable"]`, and it also inlines all fields from nested child `Params` /// structs marked with `#[nested = "Group Name"]` while prefixing that group name before the - /// parameter's originanl group name. Dereferencing the pointers stored in the values is only + /// parameter's original group name. Dereferencing the pointers stored in the values is only /// valid as long as this object is valid. /// /// # Note /// /// This uses `String` even though for the `Params` derive macro `&'static str` would have been - /// fine to be able to support custom reusable Params implemnetations. + /// fine to be able to support custom reusable Params implementations. fn param_map(&self) -> Vec<(String, ParamPtr, String)>; /// Serialize all fields marked with `#[persist = "stable_name"]` into a hash map containing @@ -88,7 +88,7 @@ pub unsafe trait Params: 'static + Send + Sync { } /// Restore all fields marked with `#[persist = "stable_name"]` from a hashmap created by - /// [`serialize_fields()`][Self::serialize_fields()]. All of thse fields should be wrapped in a + /// [`serialize_fields()`][Self::serialize_fields()]. All of these fields should be wrapped in a /// [`PersistentField`] with thread safe interior mutability, like an `RwLock` or a `Mutex`. /// This gets called when the plugin's state is being restored. This uses [deserialize_field()] /// under the hood. diff --git a/src/param/range.rs b/src/param/range.rs index a21b6ca4..dc97ca8a 100644 --- a/src/param/range.rs +++ b/src/param/range.rs @@ -167,7 +167,7 @@ impl FloatRange { } } - /// Snap a vlue to a step size, clamping to the minimum and maximum value of the range. + /// Snap a value to a step size, clamping to the minimum and maximum value of the range. pub fn snap_to_step(&self, value: f32, step_size: f32) -> f32 { match self { FloatRange::Linear { min, max } diff --git a/src/param/smoothing.rs b/src/param/smoothing.rs index c26acb3f..24d3e7b4 100644 --- a/src/param/smoothing.rs +++ b/src/param/smoothing.rs @@ -47,7 +47,7 @@ pub struct Smoother { /// uniform. /// /// In the case of the `Exponential` smoothing style this is the coefficient `x` that the - /// previous sample is multplied by. + /// previous sample is multiplied by. step_size: AtomicF32, /// The value for the current sample. Always stored as floating point for obvious reasons. current: AtomicF32, @@ -119,7 +119,7 @@ impl SmoothingStyle { /// Compute the next value from `current` leading up to `target` using the `step_size` computed /// using [`SmoothingStyle::step_size()`]. Depending on the smoothing style this function may /// never completely reach `target`, so you will need to snap to `target` yourself after - /// cmoputing the target number of steps. + /// computing the target number of steps. /// /// See the docstring on the [`SmoothingStyle::next_step()`] function for the formulas used. #[inline] @@ -229,7 +229,7 @@ impl Smoother { } /// Whether calling [`next()`][Self::next()] will yield a new value or an old value. Useful if - /// you need to recompute something wheenver this parameter changes. + /// you need to recompute something whenever this parameter changes. #[inline] pub fn is_smoothing(&self) -> bool { self.steps_left() > 0 diff --git a/src/plugin.rs b/src/plugin.rs index de62c1f5..52c2b814 100644 --- a/src/plugin.rs +++ b/src/plugin.rs @@ -52,7 +52,7 @@ pub trait Plugin: Default + Send + Sync + 'static { /// configuration works the same was as with `DEFAULT_INPUT_CHANNELS`. const DEFAULT_AUX_INPUTS: Option = None; /// If set, then the plugin will have this many auxiliary output busses with a default number of - /// channels. Negotiating the actual configuration wroks the same was as with + /// channels. Negotiating the actual configuration works the same was as with /// `DEFAULT_INPUT_CHANNELS`. const DEFAULT_AUX_OUTPUTS: Option = None; @@ -70,7 +70,7 @@ pub trait Plugin: Default + Send + Sync + 'static { /// is set to [`MidiConfig::None`], then the plugin won't receive any note events. const MIDI_INPUT: MidiConfig = MidiConfig::None; /// Whether the plugin can output note events. If this is set to [`MidiConfig::None`], then the - /// plugin won't have a note output port. When this is set to another value, then in most hsots + /// plugin won't have a note output port. When this is set to another value, then in most hosts /// the plugin will consume all note and MIDI CC input. If you don't want that, then you will /// need to forward those events yourself. const MIDI_OUTPUT: MidiConfig = MidiConfig::None; @@ -117,14 +117,14 @@ pub trait Plugin: Default + Send + Sync + 'static { /// have already been restored at this point. If based on those parameters (or for any reason /// whatsoever) the plugin needs to introduce latency, then you can do so here using the process /// context. Depending on how the host restores plugin state, this function may also be called - /// twice in rapid succession. If the plugin fails to inialize for whatever reason, then this + /// twice in rapid succession. If the plugin fails to initialize for whatever reason, then this /// should return `false`. /// /// Before this point, the plugin should not have done any expensive initialization. Please /// don't be that plugin that takes twenty seconds to scan. /// /// After this function [`reset()`][Self::reset()] will always be called. If you need to clear - /// state, such as filters or envelopes, then you should do so in that function inistead. + /// state, such as filters or envelopes, then you should do so in that function instead. fn initialize( &mut self, bus_config: &BusConfig, @@ -141,9 +141,9 @@ pub trait Plugin: Default + Send + Sync + 'static { /// Process audio. The host's input buffers have already been copied to the output buffers if /// they are not processing audio in place (most hosts do however). All channels are also - /// guarenteed to contain the same number of samples. Lastly, denormals have already been taken + /// guaranteed to contain the same number of samples. Lastly, denormals have already been taken /// case of by NIH-plug, and you can optionally enable the `assert_process_allocs` feature to - /// abort the program when any allocation accurs in the process function while running in debug + /// abort the program when any allocation occurs in the process function while running in debug /// mode. /// /// The framework provides convenient iterators on the [`Buffer`] object to process audio either @@ -159,7 +159,7 @@ pub trait Plugin: Default + Send + Sync + 'static { /// auxiliary output buffers if it has any. /// /// TODO: Provide a way to access auxiliary input channels if the IO configuration is - /// assymetric + /// asymmetric fn process( &mut self, buffer: &mut Buffer, @@ -205,7 +205,7 @@ pub trait Vst3Plugin: Plugin { /// This will be shuffled into a different byte order on Windows for project-compatibility. const VST3_CLASS_ID: [u8; 16]; /// One or more categories, separated by pipe characters (`|`), up to 127 characters. Anything - /// logner than that will be truncated. See the VST3 SDK for examples of common categories: + /// longer than that will be truncated. See the VST3 SDK for examples of common categories: /// // // TODO: Create a category enum similar to ClapFeature @@ -271,7 +271,7 @@ pub trait Editor: Send + Sync { context: Arc, ) -> Box; - /// Returns the (currnent) size of the editor in pixels as a `(width, height)` pair. This size + /// Returns the (current) size of the editor in pixels as a `(width, height)` pair. This size /// must be reported in _logical pixels_, i.e. the size before being multiplied by the DPI /// scaling factor to get the actual physical screen pixels. fn size(&self) -> (u32, u32); @@ -285,7 +285,7 @@ pub trait Editor: Send + Sync { /// there. fn set_scale_factor(&self, factor: f32) -> bool; - /// A callback that will be called wheneer the parameter values changed while the editor is + /// A callback that will be called whenever the parameter values changed while the editor is /// open. You don't need to do anything with this, but this can be used to force a redraw when /// the host sends a new value for a parameter or when a parameter change sent to the host gets /// processed. @@ -325,7 +325,7 @@ pub struct BusConfig { pub aux_output_busses: AuxiliaryIOConfig, } -/// Configuration for auxiliary inputs or outputs on [`BusCofnig`]. +/// Configuration for auxiliary inputs or outputs on [`BusConfig`]. #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] pub struct AuxiliaryIOConfig { /// The number of auxiliary input or output busses. @@ -389,7 +389,7 @@ pub enum ProcessStatus { Tail(u32), /// This plugin will continue to produce sound regardless of whether or not the input is silent, /// and should thus not be deactivated by the host. This is essentially the same as having an - /// infite tail. + /// infinite tail. KeepAlive, } diff --git a/src/util/stft.rs b/src/util/stft.rs index e50c3abb..4362a4e6 100644 --- a/src/util/stft.rs +++ b/src/util/stft.rs @@ -57,7 +57,7 @@ pub struct StftHelper { padding: usize, } -/// Marker struct for the version wtihout sidechaining. +/// Marker struct for the version without sidechaining. struct NoSidechain; impl StftInput for Buffer<'_> { @@ -255,7 +255,7 @@ impl StftHelper { self.main_input_ring_buffers.capacity() } - /// The amount of latency introduced when processing audio throug hthis [`StftHelper`]. + /// The amount of latency introduced when processing audio through this [`StftHelper`]. pub fn latency_samples(&self) -> u32 { self.main_input_ring_buffers[0].len() as u32 } @@ -496,7 +496,7 @@ impl StftHelper { /// Similar to [`process_overlap_add()`][Self::process_overlap_add()], but without the inverse /// STFT part. `buffer` will only ever be read from. This can be useful for providing FFT data /// for a spectrum analyzer in a plugin GUI. These is still a delay to the analysis equal to the - /// blcok size. + /// block size. pub fn process_analyze_only( &mut self, buffer: &B, diff --git a/src/util/window.rs b/src/util/window.rs index 638e8e7c..625075f6 100644 --- a/src/util/window.rs +++ b/src/util/window.rs @@ -1,4 +1,4 @@ -//! Windowing functions, useful in conjuction with [`StftHelper`][super::StftHelper]. +//! Windowing functions, useful in conjunction with [`StftHelper`][super::StftHelper]. use std::f32; diff --git a/src/wrapper/clap/factory.rs b/src/wrapper/clap/factory.rs index 6f335f1b..b05fa039 100644 --- a/src/wrapper/clap/factory.rs +++ b/src/wrapper/clap/factory.rs @@ -10,7 +10,7 @@ use super::descriptor::PluginDescriptor; use super::wrapper::Wrapper; use crate::plugin::ClapPlugin; -/// The plugin's factory. Initialized using a lazy_static from the entry poiunt's `get_factory()` +/// The plugin's factory. Initialized using a lazy_static from the entry point's `get_factory()` /// function. From this point onwards we don't need to generate code with macros anymore. #[doc(hidden)] #[repr(C)] diff --git a/src/wrapper/clap/util.rs b/src/wrapper/clap/util.rs index ed33834c..e9ad35f4 100644 --- a/src/wrapper/clap/util.rs +++ b/src/wrapper/clap/util.rs @@ -28,7 +28,7 @@ macro_rules! check_null_ptr_msg { /// be null pointers, people will still use null pointers for some of the function arguments. This /// also happens in the official `clap-helpers`. As such, these functions are now `Option` /// optional function pointers in `clap-sys`. This macro asserts that the pointer is not null, and -/// prints a nicely formatted error message containing the struct and funciton name if it is. It +/// prints a nicely formatted error message containing the struct and function name if it is. It /// also emulates C's syntax for accessing fields struct through a pointer. Except that it uses `=>` /// instead of `->`. Because that sounds like it would be hilarious. macro_rules! clap_call { diff --git a/src/wrapper/clap/wrapper.rs b/src/wrapper/clap/wrapper.rs index 42d5c96f..595b801a 100644 --- a/src/wrapper/clap/wrapper.rs +++ b/src/wrapper/clap/wrapper.rs @@ -143,10 +143,10 @@ pub struct Wrapper { /// The last process status returned by the plugin. This is used for tail handling. last_process_status: AtomicCell, /// The current latency in samples, as set by the plugin through the [`ProcessContext`]. uses - /// the latency extnesion + /// the latency extension pub current_latency: AtomicU32, - /// Contains slices for the plugin's outputs. You can't directly create a nested slice form - /// apointer to pointers, so this needs to be preallocated in the setup call and kept around + /// Contains slices for the plugin's outputs. You can't directly create a nested slice from + /// a pointer to pointers, so this needs to be preallocated in the setup call and kept around /// between process calls. This buffer owns the vector, because otherwise it would need to store /// a mutable reference to the data contained in this mutex. output_buffer: AtomicRefCell>, @@ -215,7 +215,7 @@ pub struct Wrapper { /// by slashes, and they're only used to allow the DAW to display parameters in a tree /// structure. param_group_by_hash: HashMap, - /// Mappings from string parameter indentifiers to parameter hashes. Useful for debug logging + /// Mappings from string parameter identifiers to parameter hashes. Useful for debug logging /// and when storing and restoring plugin state. param_id_to_hash: HashMap, /// The inverse mapping from [`param_by_hash`][Self::param_by_hash]. This is needed to be able @@ -230,7 +230,7 @@ pub struct Wrapper { /// A queue of parameter changes and gestures that should be output in either the next process /// call or in the next parameter flush. /// - /// XXX: There's no guarentee that a single parameter doesn't occur twice in this queue, but + /// XXX: There's no guarantee that a single parameter doesn't occur twice in this queue, but /// even if it does then that should still not be a problem because the host also reads it /// in the same order, right? output_parameter_events: ArrayQueue, @@ -690,7 +690,7 @@ impl Wrapper

{ } } - /// Queue a parmeter output event to be sent to the host at the end of the audio processing + /// Queue a parameter output event to be sent to the host at the end of the audio processing /// cycle, and request a parameter flush from the host if the plugin is not currently processing /// audio. The parameter's actual value will only be updated at that point so the value won't /// change in the middle of a processing call. @@ -746,7 +746,7 @@ impl Wrapper

{ /// /// After calling this function, you should call /// [`notify_param_values_changed()`][Self::notify_param_values_changed()] to allow the editor - /// to update itself. This needs to be done seperately so you can process parameter changes in + /// to update itself. This needs to be done separately so you can process parameter changes in /// batches. /// /// # Note @@ -812,13 +812,13 @@ impl Wrapper

{ } /// Similar to [`handle_in_events()`][Self::handle_in_events()], but will stop just before an - /// event if the preducate returns true for that events. This predicate is only called for + /// event if the predicate returns true for that events. This predicate is only called for /// events that occur after `current_sample_idx`. This is used to stop before a tempo or time /// signature change, or before next parameter change event with `raw_event.time > /// current_sample_idx` and return the **absolute** (relative to the entire buffer that's being /// split) sample index of that event along with the its index in the event queue as a /// `(sample_idx, event_idx)` tuple. This allows for splitting the audio buffer into segments - /// with distinct sample values to enable sample accurate automation without modifcations to the + /// with distinct sample values to enable sample accurate automation without modifications to the /// wrapped plugin. pub unsafe fn handle_in_events_until( &self, @@ -3199,7 +3199,7 @@ impl Wrapper

{ } } -/// Convenience function to query an extennsion from the host. +/// Convenience function to query an extension from the host. /// /// # Safety /// diff --git a/src/wrapper/standalone/wrapper.rs b/src/wrapper/standalone/wrapper.rs index 215aef6c..6305740f 100644 --- a/src/wrapper/standalone/wrapper.rs +++ b/src/wrapper/standalone/wrapper.rs @@ -318,7 +318,7 @@ impl Wrapper { /// processing cycle, and this won't do anything if the parameter has not been registered by the /// plugin. /// - /// This returns false if the parmeter was not set because the `Paramptr` was either unknown or + /// This returns false if the parameter was not set because the `ParamPtr` was either unknown or /// the queue is full. pub fn set_parameter(&self, param: ParamPtr, normalized: f32) -> bool { if !self.known_parameters.contains(¶m) { diff --git a/src/wrapper/state.rs b/src/wrapper/state.rs index 14a91a9f..4d7c7a17 100644 --- a/src/wrapper/state.rs +++ b/src/wrapper/state.rs @@ -40,9 +40,9 @@ pub struct PluginState { #[serde(default)] pub version: String, - /// The plugin's parameter values. These are stored unnormalized. This mean sthe old values will + /// The plugin's parameter values. These are stored unnormalized. This means the old values will /// be recalled when when the parameter's range gets increased. Doing so may still mess with - /// parameter automation though, depending on how the host impelments that. + /// parameter automation though, depending on how the host implements that. pub params: BTreeMap, /// Arbitrary fields that should be persisted together with the plugin's parameters. Any field /// on the [`Params`][crate::param::internals::Params] struct that's annotated with `#[persist = diff --git a/src/wrapper/vst3/factory.rs b/src/wrapper/vst3/factory.rs index 3c557fac..ee9d38e6 100644 --- a/src/wrapper/vst3/factory.rs +++ b/src/wrapper/vst3/factory.rs @@ -13,7 +13,7 @@ use super::wrapper::Wrapper; use crate::plugin::Vst3Plugin; use crate::wrapper::util::strlcpy; -/// The VST3 SDK version this is roughtly based on. The bindings include some VST 3.7 things but not +/// The VST3 SDK version this is roughly based on. The bindings include some VST 3.7 things but not /// everything, so we'll play it safe. const VST3_SDK_VERSION: &str = "VST 3.6.14"; diff --git a/src/wrapper/vst3/inner.rs b/src/wrapper/vst3/inner.rs index 0476285a..1fa5b70c 100644 --- a/src/wrapper/vst3/inner.rs +++ b/src/wrapper/vst3/inner.rs @@ -55,7 +55,7 @@ pub(crate) struct WrapperInner { /// This AtomicRefCell+Option is only needed because it has to be initialized late. There is no /// reason to mutably borrow the event loop, so reads will never be contested. /// - /// TODO: Is there a better type for Send+Sync late initializaiton? + /// TODO: Is there a better type for Send+Sync late initialization? pub event_loop: AtomicRefCell>>, /// Whether the plugin is currently processing audio. In other words, the last state @@ -72,8 +72,8 @@ pub(crate) struct WrapperInner { pub last_process_status: AtomicCell, /// The current latency in samples, as set by the plugin through the [`ProcessContext`]. pub current_latency: AtomicU32, - /// Contains slices for the plugin's outputs. You can't directly create a nested slice form - /// apointer to pointers, so this needs to be preallocated in the setup call and kept around + /// Contains slices for the plugin's outputs. You can't directly create a nested slice from + /// a pointer to pointers, so this needs to be preallocated in the setup call and kept around /// between process calls. This buffer owns the vector, because otherwise it would need to store /// a mutable reference to the data contained in this mutex. pub output_buffer: AtomicRefCell>, @@ -102,7 +102,7 @@ pub(crate) struct WrapperInner { pub output_events: AtomicRefCell>, /// VST3 has several useful predefined note expressions, but for some reason they are the only /// note event type that don't have MIDI note ID and channel fields. So we need to keep track of - /// the msot recent VST3 note IDs we've seen, and then map those back to MIDI note IDs and + /// the most recent VST3 note IDs we've seen, and then map those back to MIDI note IDs and /// channels as needed. pub note_expression_controller: AtomicRefCell, /// Unprocessed parameter changes and note events sent by the host during a process call. @@ -134,8 +134,8 @@ pub(crate) struct WrapperInner { /// `params` object does not get deallocated. pub param_by_hash: HashMap, pub param_units: ParamUnits, - /// Mappings from string parameter indentifiers to parameter hashes. Useful for debug logging - /// and when storing and restorign plugin state. + /// Mappings from string parameter identifiers to parameter hashes. Useful for debug logging + /// and when storing and restoring plugin state. pub param_id_to_hash: HashMap, /// The inverse mapping from [`param_by_hash`][Self::param_by_hash]. This is needed to be able /// to have an ergonomic parameter setting API that uses references to the parameters instead of @@ -153,7 +153,7 @@ pub enum Task { /// [`vst3_sys::vst::RestartFlags`]. TriggerRestart(i32), /// Request the editor to be resized according to its current size. Right now there is no way to - /// handle denied resize requestsyet. + /// handle "denied resize" requests yet. RequestResize, } @@ -384,7 +384,7 @@ impl WrapperInner

{ /// /// After calling this function, you should call /// [`notify_param_values_changed()`][Self::notify_param_values_changed()] to allow the editor - /// to update itself. This needs to be done seperately so you can process parameter changes in + /// to update itself. This needs to be done separately so you can process parameter changes in /// batches. pub fn set_normalized_value_by_hash( &self, diff --git a/src/wrapper/vst3/note_expressions.rs b/src/wrapper/vst3/note_expressions.rs index 4d0f6200..e4deda1f 100644 --- a/src/wrapper/vst3/note_expressions.rs +++ b/src/wrapper/vst3/note_expressions.rs @@ -26,7 +26,7 @@ pub const EXPRESSION_EXPRESSION_ID: u32 = 4; pub const BRIGHTNESS_EXPRESSION_ID: u32 = 5; /// The note expressions we support. It's completely undocumented, but apparently VST3 plugins need -/// to specifically define a custom note expression for the predefined note expressiosn for them to +/// to specifically define a custom note expression for the predefined note expressions for them to /// work. pub const KNOWN_NOTE_EXPRESSIONS: [NoteExpressionInfo; 6] = [ NoteExpressionInfo { diff --git a/src/wrapper/vst3/param_units.rs b/src/wrapper/vst3/param_units.rs index 506a3633..c2c98a8f 100644 --- a/src/wrapper/vst3/param_units.rs +++ b/src/wrapper/vst3/param_units.rs @@ -1,6 +1,6 @@ //! Parameter hierarchies in VST3 requires you to define units, which are linearly indexed logical //! units that have a name, a parent, and then a whole bunch of other data like note numbers and -//! MIDI program state. We'll need to implement some of that to conver our list of slash-separated +//! MIDI program state. We'll need to implement some of that to convert our list of slash-separated //! parameter group paths to units. //! //! @@ -152,7 +152,7 @@ impl ParamUnits { Some((index as i32 + 1, info)) } - /// Get the ID of the unit the paramter belongs to or. `kRootUnitId`/0 indicates the root unit. + /// Get the ID of the unit the parameter belongs to. `kRootUnitId`/0 indicates the root unit. pub fn get_vst3_unit_id(&self, param_hash: u32) -> Option { self.unit_id_by_hash.get(¶m_hash).copied() } diff --git a/src/wrapper/vst3/view.rs b/src/wrapper/vst3/view.rs index fbe5102a..dd825eea 100644 --- a/src/wrapper/vst3/view.rs +++ b/src/wrapper/vst3/view.rs @@ -80,7 +80,7 @@ struct RunLoopEventHandler { /// this object gets dropped so no work is lost. inner: Arc>, - /// The host's run lopp interface. This lets us run tasks on the same thread as the host's UI. + /// The host's run loop interface. This lets us run tasks on the same thread as the host's UI. run_loop: VstPtr, /// We need a Unix domain socket the host can poll to know that we have an event to handle. In