Struct nih_plug::params::smoothing::Smoother

pub struct Smoother<T: Smoothable> {
    pub style: SmoothingStyle,
    /* private fields */
}

A smoother, providing a smoothed value for each sample.

Fields

style: SmoothingStyle

The kind of snoothing that needs to be applied, if any.

Implementations

impl<T: Smoothable> Smoother<T>

pub fn new(style: SmoothingStyle) -> Self

Use the specified style for the smoothing.

pub fn none() -> Self

Convenience function for not applying any smoothing at all. Same as Smoother::default.

pub fn steps_left(&self) -> i32

The number of steps left until calling next() will stop yielding new values.

pub fn is_smoothing(&self) -> bool

Whether calling next() will yield a new value or an old value. Useful if you need to recompute something whenever this parameter changes.

pub fn iter(&self) -> SmootherIter<'_, T>

Produce an iterator that yields smoothed values. These are not iterators already for the sole reason that this will always yield a value, and needing to unwrap all of those options is not going to be very fun.

pub fn reset(&self, value: T)

Reset the smoother the specified value.

pub fn set_target(&self, sample_rate: f32, target: T)

Set the target value.

pub fn next(&self) -> T

Get the next value from this smoother. The value will be equal to the previous value once the smoothing period is over. This should be called exactly once per sample.

pub fn next_step(&self, steps: u32) -> T

next(), but with the ability to skip forward in the smoother. next() is equivalent to calling this function with a steps value of 1. Calling this function with a steps value of n means will cause you to skip the next n - 1 values and return the nth value.

pub fn previous_value(&self) -> T

Get previous value returned by this smoother. This may be useful to save some boilerplate when is_smoothing() is used to determine whether an expensive calculation should take place, and next() gets called as part of that calculation.

pub fn next_block(&self, block_values: &mut [T], block_len: usize)

Produce smoothed values for an entire block of audio. This is useful when iterating the same block of audio multiple times. For instance when summing voices for a synthesizer. block_values[..block_len] will be filled with the smoothed values. This is simply a convenient function for next_block_exact() when iterating over variable length blocks with a known maximum size.

Panics

Panics if block_len > block_values.len().

pub fn next_block_exact(&self, block_values: &mut [T])

The same as next_block(), but filling the entire slice.

pub fn next_block_mapped( &self, block_values: &mut [T], block_len: usize, f: impl FnMut(usize, f32) -> T )

The same as next_block(), but with a function applied to each produced value. The mapping function takes an index in the block and a floating point representation of the smoother’s current value. This allows the modulation to be consistent during smoothing. Additionally, the mapping function is always called even if the smoothing is finished.

pub fn next_block_exact_mapped( &self, block_values: &mut [T], f: impl FnMut(usize, f32) -> T )

The same as next_block_exact(), but with a function applied to each produced value. Useful when applying modulation to a smoothed parameter.

Trait Implementations

impl<T: Smoothable> Clone for Smoother<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Smoothable> Debug for Smoother<T>where T::Atomic: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Smoothable> Default for Smoother<T>

fn default() -> Self

Returns the “default value” for a type.