Struct STFT 

pub struct STFT<T: Float> { /* private fields */ }

A self-normalizing STFT, with variable position/window for output blocks

Implementations

impl<T: Float + FromPrimitive + NumCast + AddAssign> STFT<T>

pub fn new(modified: bool) -> Self

Create a new STFT instance

pub fn configure( &mut self, in_channels: usize, out_channels: usize, block_samples: usize, extra_input_history: usize, interval_samples: usize, )

Configure the STFT

pub fn block_samples(&self) -> usize

Get the block size in samples

pub fn fft_samples(&self) -> usize

Get the FFT size in samples

pub fn default_interval(&self) -> usize

Get the default interval between blocks

pub fn bands(&self) -> usize

Get the number of frequency bands

pub fn analysis_latency(&self) -> usize

Get the analysis latency

pub fn synthesis_latency(&self) -> usize

Get the synthesis latency

pub fn latency(&self) -> usize

Get the total latency

pub fn bin_to_freq(&self, bin: T) -> T

Convert bin index to frequency

pub fn freq_to_bin(&self, freq: T) -> T

Convert frequency to bin index

pub fn reset(&mut self, product_weight: T)

Reset the STFT state

pub fn reset_default(&mut self)

Reset the STFT state with default product weight

pub fn write_input( &mut self, channel: usize, offset: usize, length: usize, input_array: &[T], )

Write input samples to a specific channel

pub fn write_input_simple(&mut self, channel: usize, input_array: &[T])

Write input samples to a specific channel (without offset)

pub fn read_output( &self, channel: usize, offset: usize, length: usize, output_array: &mut [T], )

Read output samples from a specific channel

pub fn read_output_simple(&self, channel: usize, output_array: &mut [T])

Read output samples from a specific channel (without offset)

pub fn move_input(&mut self, samples: usize)

Move the input position

pub fn move_output(&mut self, samples: usize)

Move the output position

pub fn set_interval(&mut self, interval: usize, window_shape: WindowShape)

Set the interval between blocks and update windows

pub fn process_block_to_spectrum(&mut self, channel: usize) -> &[Complex<T>]

Process a block of input samples to produce a spectrum

pub fn process_spectrum_to_block( &mut self, channel: usize, spectrum: &[Complex<T>], )

Process a spectrum to produce a block of output samples

pub fn process_block(&mut self, in_channel: usize, out_channel: usize)

Process a block of input samples directly to output

pub fn process_channels( &mut self, in_channels: &[usize], out_channels: &[usize], )

Process multiple channels at once