Struct rubato::FftFixedIn

pub struct FftFixedIn<T> { /* private fields */ }

A synchronous resampler that needs a fixed number of audio frames for input and returns a variable number of frames.

The resampling is done by FFT:ing the input data. The spectrum is then extended or truncated as well as multiplied with an antialiasing filter before it’s inverse transformed to get the resampled waveforms.

Implementations

impl<T> FftFixedIn<T> where
    T: Sample, 

pub fn new(
    sample_rate_input: usize,
    sample_rate_output: usize,
    chunk_size_in: usize,
    sub_chunks: usize,
    nbr_channels: usize
) -> Result<Self, ResamplerConstructionError>

Create a new FftFixedIn

Parameters are:

• sample_rate_input: Input sample rate, must be > 0.
• sample_rate_output: Output sample rate, must be > 0.
• chunk_size_in: length of input data in frames.
• sub_chunks: desired number of subchunks for processing, actual number used may be different.
• nbr_channels: number of channels in input/output.

Trait Implementations

impl<T> Resampler<T> for FftFixedIn<T> where
    T: Sample, 

fn set_resample_ratio(&mut self, _new_ratio: f64) -> ResampleResult<()>

Update the resample ratio. This is not supported by this resampler and always returns ResampleError::SyncNotAdjustable.

fn set_resample_ratio_relative(&mut self, _rel_ratio: f64) -> ResampleResult<()>

Update the resample ratio relative to the original one. This is not supported by this resampler and always returns ResampleError::SyncNotAdjustable.

fn process_into_buffer<V: AsRef<[T]>>(
    &mut self,
    wave_in: &[V],
    wave_out: &mut [Vec<T>],
    active_channels_mask: Option<&[bool]>
) -> ResampleResult<()>

Resample a buffer of audio to a pre-allocated output buffer. Use this in real-time applications where the unpredictable time required to allocate memory from the heap can cause glitches. If this is not a problem, you may use the process method instead.

fn input_frames_max(&self) -> usize

Get the maximum number of input frames per channel the resampler could require

fn input_frames_next(&self) -> usize

Get the number of frames per channel needed for the next call to process_into_buffer or process

fn nbr_channels(&self) -> usize

Get the maximum number of channels this Resampler is configured for

fn output_frames_max(&self) -> usize

Get the max number of output frames per channel

fn output_frames_next(&self) -> usize

Get the number of frames per channel that will be output from the next call to process_into_buffer or process

fn process<V: AsRef<[T]>>(
    &mut self,
    wave_in: &[V],
    active_channels_mask: Option<&[bool]>
) -> ResampleResult<Vec<Vec<T>>>

This is a convenience wrapper for process_into_buffer that allocates the output buffer with each call. For realtime applications, use process_into_buffer with a buffer allocated by output_buffer_allocate instead of this function.

fn input_buffer_allocate(&self) -> Vec<Vec<T>>

Convenience method for allocating an input buffer suitable for use with process_into_buffer. The buffer’s capacity is big enough to prevent allocating additional heap memory before any call to process_into_buffer regardless of the current resampling ratio.

fn output_buffer_allocate(&self) -> Vec<Vec<T>>

Convenience method for allocating an output buffer suitable for use with process_into_buffer. The buffer’s capacity is big enough to prevent allocating additional heap memory during any call to process_into_buffer regardless of the current resampling ratio.