Signalsmith DSP

https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/
Admin
Signalsmith DSP is a library providing tools and utilities for digital signal processing.
Tokens:47,624
Snippets:301
Trust Score:9.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Example with All Parameters Set to Nonzero Values in Signalsmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

This example initializes Signalsmith DSP with a specific set of non-zero parameters, including room size. It serves as a starting point for more complex acoustic simulations or as a reference for typical parameter configurations.

```rust
fn example_with_all_params() {
    println!("\n=== All Parameters Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    spacing.set_room_size(1.5);
}
```

--------------------------------

### Full Parameter Configuration in SignalSmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

An example demonstrating the initialization of the Spacing struct with all its key parameters set to non-zero values. This includes setting the sample rate, room size, damping, diffusion, bass boost, decay, and cross-mix. This snippet serves as a starting point for users who want to configure a complex acoustic environment immediately. Further code would involve adding sources, receivers, and processing audio.

```rust
fn example_with_all_params() {
    println!("\n=== All Parameters Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    spacing.set_room_size(1.5);
    spacing.set_damping(0.3);
    spacing.set_diff(0.5);
    spacing.set_bass(3.0);
    spacing.set_decay(0.5);
    spacing.set_cross(0.3);
    // Further code would add sources, receivers, paths and process audio
}
```

--------------------------------

### All Parameters Example with Signalsmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

This example initializes the Spacing object with a sample rate and then sets all room parameters to non-zero values. This serves as a basic test case to ensure the Spacing object can be configured with various settings. The example is cut short after setting the room size.

```Rust
fn example_with_all_params() {
    println!("\n=== All Parameters Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    spacing.set_room_size(1.5);

```

--------------------------------

### Signalsmith DSP Example with All Parameters

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

An example demonstrating the initialization of the Spacing structure with a sample rate and setting several key parameters for room simulation, including room size, damping, diffusion, bass, decay, and cross-mix. This snippet is incomplete and likely intended for further expansion.

```Rust
fn example_with_all_params() {
    println!("\n=== All Parameters Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    spacing.set_room_size(1.5);
    // Further parameters would be set here...
```

--------------------------------

### Stereo to Multi-Channel and Multi-Channel to Stereo Mixing Example

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/mix/struct

Demonstrates how to use the StereoMultiMixer to convert audio signals between stereo and multi-channel formats. It shows the creation of the mixer, input/output buffers, and the calls for conversion. This example also prints the scaling factors used in the downmix.

```rust
fn stereo_multi_mixer_example() {
    println!("\nStereo Multi Mixer Example:");
    
    // Create a stereo to multi-channel mixer for 5 channels
    let mixer = StereoMultiMixer::<f32>::new(4);
    
    // Create stereo input
    let stereo_input = [0.7, 0.3]; // Left and right channels
    
    // Create multi-channel output buffer
    let mut multi_output = [0.0; 5];
    
    // Convert stereo to multi-channel
    mixer.stereo_to_multi(&stereo_input, &mut multi_output);
    
    // Print multi-channel output
    println!("Stereo input: [{:.1}, {:.1}]", stereo_input[0], stereo_input[1]);
    print!("Multi-channel output: ");
    for val in multi_output.iter() {
        print!("{:.3} ", val);
    }
    println!();
    
    // Create multi-channel input
    let multi_input = [0.2, 0.4, 0.6, 0.8, 1.0];
    
    // Create stereo output buffer
    let mut stereo_output = [0.0, 0.0];
    
    // Convert multi-channel to stereo
    mixer.multi_to_stereo(&multi_input, &mut stereo_output);
    
    // Print stereo output
    print!("Multi-channel input: ");
    for val in multi_input.iter() {
        print!("{:.1} ", val);
    }
    println!();
    println!("Stereo output: [{:.3}, {:.3}]", stereo_output[0], stereo_output[1]);
    
    // Print scaling factors
    println!("Scaling factor 1: {:.3}", mixer.scaling_factor1());
    println!("Scaling factor 2: {:.3}", mixer.scaling_factor2());
}
```

--------------------------------

### Stereo to Multi-Channel Mixer Example (Rust)

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/mix/struct

This example demonstrates how to use the StereoMultiMixer to convert stereo audio signals to multi-channel audio signals (up to 5 channels) and vice versa. It initializes the mixer, defines input and output buffers, performs the conversions, and prints the results, including scaling factors.

```rust
fn stereo_multi_mixer_example() {
    println!("\nStereo Multi Mixer Example:");
    
    // Create a stereo to multi-channel mixer for 5 channels
    let mixer = StereoMultiMixer::<f32>::new(4);
    
    // Create stereo input
    let stereo_input = [0.7, 0.3]; // Left and right channels
    
    // Create multi-channel output buffer
    let mut multi_output = [0.0; 5];
    
    // Convert stereo to multi-channel
    mixer.stereo_to_multi(&stereo_input, &mut multi_output);
    
    // Print multi-channel output
    println!("Stereo input: [{:.1}, {:.1}]", stereo_input[0], stereo_input[1]);
    print!("Multi-channel output: ");
    for val in multi_output.iter() {
        print!( “{:.3} ”, val);
    }
    println!();
    
    // Create multi-channel input
    let multi_input = [0.2, 0.4, 0.6, 0.8, 1.0];
    
    // Create stereo output buffer
    let mut stereo_output = [0.0, 0.0];
    
    // Convert multi-channel to stereo
    mixer.multi_to_stereo(&multi_input, &mut stereo_output);
    
    // Print stereo output
    print!("Multi-channel input: ");
    for val in multi_input.iter() {
        print!( “{:.1} ”, val);
    }
    println!();
    println!("Stereo output: [{:.3}, {:.3}]", stereo_output[0], stereo_output[1]);
    
    // Print scaling factors
    println!("Scaling factor 1: {:.3}", mixer.scaling_factor1());
    println!("Scaling factor 2: {:.3}", mixer.scaling_factor2());
}
```

--------------------------------

### Mono Time-Stretch and Pitch-Shift Example in Rust

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stretch/struct

Demonstrates mono audio time-stretching and pitch-shifting using SignalsmithStretch. It configures the stretch parameters, processes input audio, and prints sample input and output data. The example involves setting transpose and formant semitones.

```rust
fn mono_ramp_demo() {
    println!("=== Mono ramp time-stretch & pitch-shift ===");
    let sample_rate = 48000.0_f32;
    let channels = 1;
    let block_samples = 1024;
    let interval_samples = 256;
    let input_len = 2048;
    let mut input: Vec<Vec<f32>> = vec![vec![0.0; input_len]; channels];
    for i in 0..input_len {
        input[0][i] = (i as f32 / input_len as f32) * 2.0 - 1.0;
    }
    let output_len = (input_len as f32 * 1.5) as usize;
    let mut output: Vec<Vec<f32>> = vec![vec![0.0; output_len]; channels];
    let mut stretch = SignalsmithStretch::<f32>::new();
    stretch.configure(channels, block_samples, interval_samples, false);
    stretch.set_transpose_semitones(3.0, 0.0);
    stretch.set_formant_semitones(1.0, false);
    stretch.process(&input, input_len, &mut output, output_len);
    println!("Input (first 10): {:?}", &input[0][..10]);
    println!("Output (first 10): {:?}", &output[0][..10]);
    println!("Output (last 10): {:?}
", &output[0][output_len-10..]);
}
```

--------------------------------

### Example of Spectral Utilities in Rust

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spectral/utils/fn

Demonstrates the usage of various spectral utility functions within the signalsmith-dsp crate. This example showcases converting between magnitude/phase and complex numbers, linear and dB scales, and applying gain, phase shifts, and time shifts to a spectrum. It requires the `Complex` type and other utility functions from the crate.

```rust
fn spectral_utilities_example() {
    println!("\nSpectral Utilities Example:");
    
    // Create a spectrum
    let mut spectrum = vec![
        Complex::new(1.0, 0.0),
        Complex::new(0.8, 0.2),
        Complex::new(0.6, 0.4),
        Complex::new(0.4, 0.6),
        Complex::new(0.2, 0.8),
        Complex::new(0.0, 1.0),
    ];
    
    // Print the original spectrum
    println!("Original spectrum:");
    for (i, &c) in spectrum.iter().enumerate() {
        let (mag, phase) = complex_to_mag_phase(c);
        println!("Bin {}: complex=({:.3}, {:.3}), magnitude={:.3}, phase={:.3}", 
                 i, c.re, c.im, mag, phase);
    }
    
    // Convert between magnitude/phase and complex
    println!("\nMagnitude/phase to complex conversion:");
    let mag = 2.0;
    let phase = 0.5;
    let complex = mag_phase_to_complex(mag, phase);
    println!("Magnitude={:.3}, Phase={:.3} -> Complex=({:.3}, {:.3})",
             mag, phase, complex.re, complex.im);
    
    let (mag_back, phase_back) = complex_to_mag_phase(complex);
    println!("Complex=({:.3}, {:.3}) -> Magnitude={:.3}, Phase={:.3}",
             complex.re, complex.im, mag_back, phase_back);
    
    // Convert between linear and dB
    println!("\nLinear to dB conversion:");
    let linear_values = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0];
    for &linear in &linear_values {
        let db = linear_to_db(linear);
        println!("Linear={:.3} -> dB={:.3}", linear, db);
        
        let linear_back = db_to_linear(db);
        println!("dB={:.3} -> Linear={:.3}", db, linear_back);
    }
    
    // Apply gain to the spectrum
    println!("\nApplying gain to the spectrum:");
    let gain_db = 6.0; // 6 dB gain
    apply_gain(&mut spectrum, gain_db);
    
    println!("After applying {:.1} dB gain:", gain_db);
    for (i, &c) in spectrum.iter().enumerate() {
        let (mag, phase) = complex_to_mag_phase(c);
        println!("Bin {}: magnitude={:.3}, phase={:.3}", i, mag, phase);
    }
    
    // Apply phase shift to the spectrum
    println!("\nApplying phase shift to the spectrum:");
    let phase_shift = 0.5; // 0.5 radians
    apply_phase_shift(&mut spectrum, phase_shift);
    
    println!("After applying {:.1} radians phase shift:", phase_shift);
    for (i, &c) in spectrum.iter().enumerate() {
        let (mag, phase) = complex_to_mag_phase(c);
        println!("Bin {}: magnitude={:.3}, phase={:.3}", i, mag, phase);
    }
    
    // Apply time shift to the spectrum
    println!("\nApplying time shift to the spectrum:");
    let time_shift = 10.0; // 10 samples
    let sample_rate = 44100.0; // 44.1 kHz
    apply_time_shift(&mut spectrum, time_shift, sample_rate);
    
    println!("After applying {:.1} samples time shift:", time_shift);
    for (i, &c) in spectrum.iter().enumerate() {
        let (mag, phase) = complex_to_mag_phase(c);
        println!("Bin {}: magnitude={:.3}, phase={:.3}", i, mag, phase);
    }
}
```

--------------------------------

### Two Sources Example with Signalsmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

This example demonstrates how to handle multiple sound sources emitting impulses at different times using Signalsmith DSP. It configures a single receiver and applies direct paths from two sources, then processes the combined input. This showcases the library's ability to manage distinct source behaviors.

```rust
fn example_two_sources() {
    println!("\n=== Two Sources Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    spacing.set_diff(0.7); // Stronger diffusion
    let src1 = spacing.add_source(Position { x: 0.0, y: 0.0, z: 0.0 });
    let src2 = spacing.add_source(Position { x: 1.0, y: 0.0, z: 0.0 });
    let recv = spacing.add_receiver(Position { x: 3.43, y: 0.0, z: 0.0 });
    spacing.add_path(src1, recv, 1.0, 0.0);
    spacing.add_path(src2, recv, 0.5, 0.0);
    let mut input1 = vec![0.0; 64];
    input1[0] = 1.0;
    let mut input2 = vec![0.0; 64];
    input2[20] = 1.0;
    let inputs: [&[f32]; 2] = [&input1, &input2];
    let mut outputs = vec![vec![0.0; 64]];
    spacing.process(&inputs, &mut outputs);
    println!("Receiver output (first 30 samples): {:?}", &outputs[0][..30]);
}
```

--------------------------------

### Basic STFT Reconstruction Example

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stft/struct

Demonstrates the basic functionality of the STFT processor for signal reconstruction. It configures the STFT, processes a sine wave in blocks, and calculates the reconstruction error. This example requires the STFT and WindowShape types from the signalsmith_dsp crate.

```rust
use std::f32::consts::PI;
use signalsmith_dsp::{STFT, WindowShape};

fn basic_stft_example() {
    println!("\nBasic STFT Example:");
    
    // Create a new STFT processor (non-modified version)
    let mut stft = STFT::<f32>::new(false);
    
    // Configure the STFT
    // - 1 input channel, 1 output channel
    // - 1024 samples per block
    // - 0 extra input history
    // - 256 samples hop size (75% overlap)
    stft.configure(1, 1, 1024, 0, 256);
    
    // Reset with default settings
    stft.reset_default();
    
    // Set the window shape and interval
    stft.set_interval(256, WindowShape::Kaiser);
    
    // Generate a test signal (sine wave at 440 Hz, 44.1 kHz sample rate)
    let sample_rate = 44100.0;
    let frequency = 440.0;
    let duration_samples = 4096; // About 93 ms
    
    let mut input_signal = vec![0.0; duration_samples];
    for i in 0..duration_samples {
        input_signal[i] = (2.0 * PI * frequency * (i as f32) / sample_rate as f32).sin();
    }
    
    // Process the signal in blocks
    let mut output_signal = vec![0.0; duration_samples];
    let mut position = 0;
    
    while position + stft.block_samples() <= duration_samples {
        // Write input block
        stft.write_input(0, 0, stft.block_samples(), &input_signal[position..position + stft.block_samples()]);
        
        // Process block (input channel 0 to output channel 0)
        stft.process_block(0, 0);
        
        // Read output block
        stft.read_output(0, 0, stft.block_samples(), &mut output_signal[position..position + stft.block_samples()]);
        
        // Move to next block
        position += stft.default_interval();
        stft.move_input(stft.default_interval());
        stft.move_output(stft.default_interval());
    }
    
    // Calculate the error between input and output
    let mut max_error = 0.0;
    for i in stft.latency()..duration_samples - stft.latency() {
        let error = (input_signal[i] - output_signal[i]).abs();
        if error > max_error {
            max_error = error;
        }
    }
    
    println!("Maximum reconstruction error: {}", max_error);
    println!("Total latency: {} samples", stft.latency());
}

```

--------------------------------

### Basic STFT Reconstruction Example in Rust

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stft/struct

Demonstrates the basic usage of the STFT processor for signal reconstruction. It configures the STFT, generates a sine wave signal, processes it in blocks, and calculates the reconstruction error. This example highlights the core functionalities of writing input, processing blocks, and reading output.

```Rust
fn basic_stft_example() {
    println!("\nBasic STFT Example:");
    
    // Create a new STFT processor (non-modified version)
    let mut stft = STFT::<f32>::new(false);
    
    // Configure the STFT
    // - 1 input channel, 1 output channel
    // - 1024 samples per block
    // - 0 extra input history
    // - 256 samples hop size (75% overlap)
    stft.configure(1, 1, 1024, 0, 256);
    
    // Reset with default settings
    stft.reset_default();
    
    // Set the window shape and interval
    stft.set_interval(256, WindowShape::Kaiser);
    
    // Generate a test signal (sine wave at 440 Hz, 44.1 kHz sample rate)
    let sample_rate = 44100.0;
    let frequency = 440.0;
    let duration_samples = 4096; // About 93 ms
    
    let mut input_signal = vec![0.0; duration_samples];
    for i in 0..duration_samples {
        input_signal[i] = (2.0 * PI * frequency * (i as f32) / sample_rate as f32).sin();
    }
    
    // Process the signal in blocks
    let mut output_signal = vec![0.0; duration_samples];
    let mut position = 0;
    
    while position + stft.block_samples() <= duration_samples {
        // Write input block
        stft.write_input(0, 0, stft.block_samples(), &input_signal[position..position + stft.block_samples()]);
        
        // Process block (input channel 0 to output channel 0)
        stft.process_block(0, 0);
        
        // Read output block
        stft.read_output(0, 0, stft.block_samples(), &mut output_signal[position..position + stft.block_samples()]);
        
        // Move to next block
        position += stft.default_interval();
        stft.move_input(stft.default_interval());
        stft.move_output(stft.default_interval());
    }
    
    // Calculate the error between input and output
    let mut max_error = 0.0;
    for i in stft.latency()..duration_samples - stft.latency() {
        let error = (input_signal[i] - output_signal[i]).abs();
        if error > max_error {
            max_error = error;
        }
    }
    
    println!("Maximum reconstruction error: {}", max_error);
    println!("Total latency: {} samples", stft.latency());
}
```

--------------------------------

### Rust: StereoBiquad Filter Example

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/filters/struct

Demonstrates the creation and usage of a StereoBiquad filter in Rust. It initializes a stereo biquad, configures it as a lowpass filter, and processes stereo audio buffers. This example highlights setting up the filter and applying it to distinct left and right channel inputs.

```Rust
fn stereo_filter_example() {
    println!("\nStereo Filter Example:");
    
    // Create a stereo biquad filter
    let mut stereo_filter = StereoBiquad::<f32>::new(true);
    
    // Configure as a lowpass filter
    stereo_filter.lowpass(0.2, 0.7, BiquadDesign::Cookbook);
    
    // Create stereo input (left and right channels)
    let mut left = vec![0.0; 10];
    let mut right = vec![0.0; 10];
    
    // Set different impulses for left and right
    left[0] = 1.0;
    right[5] = 0.8;
    
    // Process the stereo buffer
    stereo_filter.process_buffer(&mut left, &mut right);
    
    // Print the results
    println!("Stereo filter output:");
    println!("      Left    Right");
    for i in 0..10 {
        println!("{}: {:.4}  {:.4}", i, left[i], right[i]);
    }
}
```

--------------------------------

### STFT: Spectral Processing Example with Pitch Shift

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stft/struct

An example demonstrating a simple pitch shifting effect using the STFT. It involves processing blocks to spectra, modifying the spectral bins to achieve the pitch shift, and then processing the modified spectra back to time-domain blocks. The example also includes printing input/output sample comparisons.

```rust
fn spectral_processing_example() {
    println!("\nSpectral Processing Example (Simple Pitch Shift):");
    
    // Create a new STFT processor
    let mut stft = STFT::<f32>::new(true); // Use modified STFT for better phase handling
    
    // Configure the STFT
    stft.configure(1, 1, 2048, 0, 512);
    stft.reset_default();
    stft.set_interval(512, WindowShape::Kaiser);
    
    // Generate a test signal (sine wave at 440 Hz, 44.1 kHz sample rate)
    let sample_rate = 44100.0;
    let frequency = 440.0;
    let duration_samples = 8192; // About 186 ms
    
    let mut input_signal = vec![0.0; duration_samples];
    for i in 0..duration_samples {
        input_signal[i] = (2.0 * PI * frequency * (i as f32) / sample_rate as f32).sin();
    }
    
    // Process the signal in blocks with spectral modification
    let mut output_signal = vec![0.0; duration_samples];
    let mut position = 0;
    
    // Pitch shift factor (1.5 = up a perfect fifth)
    let pitch_shift_factor = 1.5;
    
    while position + stft.block_samples() <= duration_samples {
        // Write input block
        stft.write_input(0, 0, stft.block_samples(), &input_signal[position..position + stft.block_samples()]);
        
        // Process block to spectrum
        let spectrum = stft.process_block_to_spectrum(0).to_vec();
        
        // Apply pitch shift (very simple version - just shifts the bins)
        let mut shifted_spectrum = vec![Complex::new(0.0, 0.0); spectrum.len()];
        
        for i in 0..spectrum.len() {
            let shifted_bin = (i as f32 * pitch_shift_factor) as usize;
            if shifted_bin < spectrum.len() {
                shifted_spectrum[shifted_bin] = spectrum[i];
            }
        }
        
        // Process spectrum back to time domain
        stft.process_spectrum_to_block(0, &shifted_spectrum);
        
        // Read output block
        stft.read_output(0, 0, stft.block_samples(), &mut output_signal[position..position + stft.block_samples()]);
        
        // Move to next block
        position += stft.default_interval();
        stft.move_input(stft.default_interval());
        stft.move_output(stft.default_interval());
    }
    
    // Print information about the pitch shift
    println!("Original frequency: {} Hz", frequency);
    println!("Shifted frequency: {} Hz", frequency * pitch_shift_factor);
    println!("Pitch shift factor: {}", pitch_shift_factor);
    
    // Print a few samples of input and output
    println!("\nSample comparison (first 10 samples after latency):");
    println!("Sample | Input    | Output");
    println!("-------|----------|--------");
    let start = stft.latency();
    for i in start..start + 10 {
        println!("{:6} | {:8.5} | {:8.5}", i, input_signal[i], output_signal[i]);
    }
}
```

--------------------------------

### Kaiser Window Function Example

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/windows/struct

Demonstrates the creation and usage of the Kaiser window function, including initialization with beta and bandwidth, and conversion between bandwidth and beta parameters. It also shows how to fill a buffer with window values and print them. Dependencies include the `Kaiser` struct and helper functions for printing.

```rust
fn kaiser_window_example() {
    println!("\nKaiser Window Example:");
    
    // Create a Kaiser window with beta=6.0
    let kaiser = Kaiser::new(6.0);
    
    // Create a buffer to hold the window
    let mut window = vec![0.0f32; 64];
    
    // Fill the buffer with the window function
    kaiser.fill(&mut window);
    
    // Print the window values
    println!("Kaiser window values (beta=6.0):");
    print_window_values(&window);
    
    // Create a Kaiser window with a specific bandwidth
    let kaiser_bw = Kaiser::with_bandwidth(2.5, true);
    
    // Create a buffer to hold the window
    let mut window_bw = vec![0.0f32; 64];
    
    // Fill the buffer with the window function
    kaiser_bw.fill(&mut window_bw);
    
    // Print the window values
    println!("\nKaiser window values (bandwidth=2.5):");
    print_window_values(&window_bw);
    
    // Demonstrate bandwidth to beta conversion
    let bandwidth = 3.0;
    let beta = Kaiser::bandwidth_to_beta(bandwidth, false);
    let beta_heuristic = Kaiser::bandwidth_to_beta(bandwidth, true);
    
    println!("\nBandwidth to beta conversion:");
    println!("Bandwidth: {:.2}", bandwidth);
    println!("Beta (direct): {:.4}", beta);
    println!("Beta (with heuristic): {:.4}", beta_heuristic);
}
```

--------------------------------

### Stereo Time-Stretch and Pitch-Shift Example in Rust

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stretch/struct

Demonstrates stereo audio time-stretching and pitch-shifting. It configures the stretch parameters for stereo channels, processes input audio with different left and right channel signals, and prints sample input and output data. The example involves setting transpose semitones for pitch down.

```rust
fn stereo_demo() {
    println!("=== Stereo time-stretch & pitch-shift ===");
    let sample_rate = 48000.0_f32;
    let channels = 2;
    let block_samples = 1024;
    let interval_samples = 256;
    let input_len = 2048;
    let mut input: Vec<Vec<f32>> = vec![vec![0.0; input_len]; channels];
    for i in 0..input_len {
        input[0][i] = ((i as f32 / input_len as f32) * 2.0 - 1.0) * 0.8; // left
        input[1][i] = (((input_len - i) as f32 / input_len as f32) * 2.0 - 1.0) * 0.5; // right
    }
    let output_len = (input_len as f32 * 0.75) as usize;
    let mut output: Vec<Vec<f32>> = vec![vec![0.0; output_len]; channels];
    let mut stretch = SignalsmithStretch::<f32>::new();
    stretch.configure(channels, block_samples, interval_samples, false);
    stretch.set_transpose_semitones(-5.0, 0.0); // pitch down
    stretch.process(&input, input_len, &mut output, output_len);
    println!("Stereo input L (first 10): {:?}", &input[0][..10]);
    println!("Stereo input R (first 10): {:?}", &input[1][..10]);
    println!("Stereo output L (first 10): {:?}", &output[0][..10]);
    println!("Stereo output R (first 10): {:?}
", &output[1][..10]);
}
```

--------------------------------

### SignalsmithStretch Configuration Methods (Rust)

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stretch/struct

Provides examples of different configuration methods for the SignalsmithStretch processor. These include manual configuration with specific block and interval samples, and preset configurations like 'default' and 'cheaper', which abstract away some parameters. Each method takes parameters like the number of channels and sample rate.

```rust
pub fn configure( &mut self, n_channels: usize, block_samples: usize, interval_samples: usize, split_computation: bool, )

pub fn preset_default( &mut self, n_channels: usize, sample_rate: T, split_computation: bool, )

pub fn preset_cheaper( &mut self, n_channels: usize, sample_rate: T, split_computation: bool, )
```

--------------------------------

### Configure and Process Audio with Signalsmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

This example demonstrates configuring the Signalsmith DSP spacing with various acoustic parameters, adding multiple sources and receivers, defining paths between them, and processing input audio signals to generate output signals. The output for each receiver is then printed.

```rust
fn example() {
    let mut spacing = Spacing::new(44100.0);
    spacing.set_damping(0.4);
    spacing.set_diff(0.8);
    spacing.set_bass(-4.0);
    spacing.set_decay(0.6);
    spacing.set_cross(0.9);
    let src1 = spacing.add_source(Position { x: 0.0, y: 0.0, z: 0.0 });
    let src2 = spacing.add_source(Position { x: 2.0, y: 0.0, z: 0.0 });
    let recv1 = spacing.add_receiver(Position { x: 5.0, y: 0.0, z: 0.0 });
    let recv2 = spacing.add_receiver(Position { x: 5.0, y: 3.0, z: 0.0 });
    spacing.add_path(src1, recv1, 1.0, 0.0);
    spacing.add_path(src2, recv2, 0.8, 0.0);
    spacing.add_path(src1, recv2, 0.5, 3.0);
    let mut input1 = vec![0.0; 40];
    input1[0] = 1.0;
    let mut input2 = vec![0.0; 40];
    input2[10] = 1.0;
    let inputs: [&[f32]; 2] = [&input1, &input2];
    let mut outputs = vec![vec![0.0; 40]; 2];
    spacing.process(&inputs, &mut outputs);
    for (idx, out) in outputs.iter().enumerate() {
        println!("Receiver {} output: {:?}", idx, &out[..20]);
    }
}
```

--------------------------------

### Rust: Compare Performance of Complex Multiplication With and Without StopDenormals

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/perf/struct

This Rust example compares the performance of standard vs. optimized complex number multiplication. It measures the time taken for both methods and then repeats the comparison while the StopDenormals feature is active. This highlights potential performance improvements or regressions when dealing with denormalized numbers. The example uses the `Instant` for timing and prints the speedup or slowdown observed.

```rust
fn performance_comparison_example() {
    println!("\nPerformance Comparison Example:");
    
    // Parameters for the test
    const NUM_ITERATIONS: usize = 1_000_000;
    const ARRAY_SIZE: usize = 1000;
    
    // Create arrays of complex numbers
    let mut a = vec![Complex::new(0.0, 0.0); ARRAY_SIZE];
    let mut b = vec![Complex::new(0.0, 0.0); ARRAY_SIZE];
    let mut c_standard = vec![Complex::new(0.0, 0.0); ARRAY_SIZE];
    let mut c_optimized = vec![Complex::new(0.0, 0.0); ARRAY_SIZE];
    
    // Initialize with some values
    for i in 0..ARRAY_SIZE {
        a[i] = Complex::new(i as f32 * 0.01, (i as f32 + 0.5) * 0.01);
        b[i] = Complex::new((i as f32 + 0.3) * 0.01, (i as f32 + 0.7) * 0.01);
    }
    
    // Test standard complex multiplication
    println!("Testing standard complex multiplication...");
    let start = Instant::now();
    for _ in 0..NUM_ITERATIONS / ARRAY_SIZE {
        for i in 0..ARRAY_SIZE {
            c_standard[i] = a[i] * b[i];
        }
    }
    let standard_duration = start.elapsed();
    
    // Test optimized complex multiplication
    println!("Testing optimized complex multiplication...");
    let start = Instant::now();
    for _ in 0..NUM_ITERATIONS / ARRAY_SIZE {
        for i in 0..ARRAY_SIZE {
            c_optimized[i] = mul(a[i], b[i]);
        }
    }
    let optimized_duration = start.elapsed();
    
    // Print results
    println!("Standard multiplication time: {:?}", standard_duration);
    println!("Optimized multiplication time: {:?}", optimized_duration);
    
    if optimized_duration < standard_duration {
        let speedup = standard_duration.as_nanos() as f64 / optimized_duration.as_nanos() as f64;
        println!("Optimized version is {:.2}x faster", speedup);
    } else {
        let slowdown = optimized_duration.as_nanos() as f64 / standard_duration.as_nanos() as f64;
        println!("Optimized version is {:.2}x slower", slowdown);
    }
    
    // Now test with StopDenormals
    println!("\nTesting with StopDenormals...");
    
    // Without StopDenormals
    println!("Without StopDenormals:");
    let start = Instant::now();
    for _ in 0..NUM_ITERATIONS / ARRAY_SIZE {
        for i in 0..ARRAY_SIZE {
            c_standard[i] = a[i] * b[i] * Complex::new(1e-30, 1e-30);
        }
    }
    let without_stop_denormals = start.elapsed();
    println!("Time: {:?}", without_stop_denormals);
    
    // With StopDenormals
    println!("With StopDenormals:");
    let _stop_denormals = StopDenormals::new();
    let start = Instant::now();
    for _ in 0..NUM_ITERATIONS / ARRAY_SIZE {
        for i in 0..ARRAY_SIZE {
            c_standard[i] = a[i] * b[i] * Complex::new(1e-30, 1e-30);
        }
    }
    let with_stop_denormals = start.elapsed();
    println!("Time: {:?}", with_stop_denormals);
    
    if with_stop_denormals < without_stop_denormals {
        let speedup = without_stop_denormals.as_nanos() as f64 / with_stop_denormals.as_nanos() as f64;
        println!("With StopDenormals is {:.2}x faster", speedup);
    } else {
        let slowdown = with_stop_denormals.as_nanos() as f64 / without_stop_denormals.as_nanos() as f64;
        println!("With StopDenormals is {:.2}x slower", slowdown);
    }
}
```

--------------------------------

### Perfect Reconstruction Example

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/windows/struct

Demonstrates how to apply perfect reconstruction to a windowed signal. It involves creating a window, applying the `force_perfect_reconstruction` function with specified overlap, and then verifying the reconstruction. Dependencies include `Kaiser`, `force_perfect_reconstruction`, and `verify_perfect_reconstruction`.

```rust
fn perfect_reconstruction_example() {
    println!("\nPerfect Reconstruction Example:");
    
    // Create a window
    let kaiser = Kaiser::new(6.0);
    let mut window = vec![0.0f32; 1024];
    kaiser.fill(&mut window);
    
    // Print some of the original window values
    println!("Original window values (first 5):");
    for i in 0..5 {
        println!("Index {}: {:.6}", i, window[i]);
    }
    
    // Apply perfect reconstruction for 4x overlap
    force_perfect_reconstruction(&mut window, 1024, 256);
    
    // Print some of the modified window values
    println!("\nModified window values for perfect reconstruction (first 5):");
    for i in 0..5 {
        println!("Index {}: {:.6}", i, window[i]);
    }
    
    // Verify perfect reconstruction
    println!("\nVerifying perfect reconstruction:");
    verify_perfect_reconstruction(&window, 256);
}
```

--------------------------------

### Basic Room Simulation with Signalsmith DSP

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spacing/struct

Demonstrates a basic room acoustics simulation using Signalsmith DSP. It sets room parameters, adds sources and receivers, defines direct and reflected paths, and processes an impulse input to generate output. This example highlights initializing Spacing, setting parameters like room size and damping, and adding paths.

```rust
fn example_basic_room() {
    println!("\n=== Basic Room Example ===");
    let sample_rate = 48000.0;
    let mut spacing = Spacing::new(sample_rate);
    // Set reverb-like parameters
    spacing.set_room_size(1.2); // 20% larger room
    spacing.set_damping(0.2);   // Some high-frequency damping
    spacing.set_diff(0.5);      // 50% input diffusion
    spacing.set_bass(6.0);      // +6 dB bass boost
    spacing.set_decay(0.3);     // moderate decay
    spacing.set_cross(0.4);     // 40% cross-mix
    println!("Room size: {}  Damping: {}  Diff: {}  Bass: {}dB  Decay: {}  Cross: {}", spacing.room_size, spacing.damping, spacing.diff, spacing.bass, spacing.decay, spacing.cross);
    // Add two sources and two receivers
    let src1 = spacing.add_source(Position { x: 0.0, y: 0.0, z: 0.0 });
    let src2 = spacing.add_source(Position { x: 2.0, y: 0.0, z: 0.0 });
    let recv1 = spacing.add_receiver(Position { x: 5.0, y: 0.0, z: 0.0 });
    let recv2 = spacing.add_receiver(Position { x: 5.0, y: 3.0, z: 0.0 });
    // Add direct paths
    spacing.add_path(src1, recv1, 1.0, 0.0);
    spacing.add_path(src2, recv2, 0.8, 0.0);
    // Add a reflection (extra distance)
    spacing.add_path(src1, recv2, 0.5, 3.0); // Simulate a wall reflection
    // Prepare input (impulse) for each source
    let mut input1 = vec![0.0; 32];
    input1[0] = 1.0;
    let mut input2 = vec![0.0; 32];
    // Only src1 emits an impulse in this example
    let inputs: [&[f32]; 2] = [&input1, &input2];
    // Prepare outputs for each receiver
    let mut outputs = vec![vec![0.0; 32]; 2];
    spacing.process(&inputs, &mut outputs);
    // Print first 10 samples for each receiver
    for (idx, out) in outputs.iter().enumerate() {
        println!("Receiver {} output: {:?}", idx, &out[..10]);
    }
}
```

--------------------------------

### WindowedFFT Example Usage

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/spectral/struct

Demonstrates the usage of the WindowedFFT struct in Rust. It shows how to create an FFT instance, fill an input buffer with a sine wave, perform a forward FFT, and then an inverse FFT to reconstruct the signal. It also illustrates creating an FFT with a custom Kaiser window.

```rust
fn windowed_fft_example() {
    println!("\nWindowed FFT Example:");
    
    // Create a windowed FFT with size 1024 and no rotation
    let mut windowed_fft = WindowedFFT::<f32>::new(1024, 0);
    
    // Create input and output buffers
    let mut time_domain = vec![0.0; 1024];
    let mut freq_domain = vec![Complex::new(0.0, 0.0); 1024];
    
    // Fill input with a sine wave
    for i in 0..1024 {
        time_domain[i] = (i as f32 * 0.1).sin();
    }
    
    // Print some of the input signal
    println!("Input signal (first 10 samples):");
    for i in 0..10 {
        println!("Sample {}: {:.6}", i, time_domain[i]);
    }
    
    // Perform forward FFT with windowing and scaling
    windowed_fft.fft(&time_domain, &mut freq_domain, true, true);
    
    // Print some of the frequency domain data
    println!("\nFrequency domain (first 10 bins):");
    for i in 0..10 {
        let (mag, phase) = complex_to_mag_phase(freq_domain[i]);
        println!("Bin {}: magnitude={:.6}, phase={:.6}", i, mag, phase);
    }
    
    // Perform inverse FFT with windowing
    windowed_fft.ifft(&freq_domain, &mut time_domain, true);
    
    // Print some of the reconstructed signal
    println!("\nReconstructed signal (first 10 samples):");
    for i in 0..10 {
        println!("Sample {}: {:.6}", i, time_domain[i]);
    }
    
    // Create a windowed FFT with a custom window
    println!("\nCreating a windowed FFT with a custom Kaiser window:");
    let kaiser = Kaiser::new(6.0);
    let mut window_buffer = vec![0.0; 1024];
    kaiser.fill(&mut window_buffer);
    
    let mut windowed_fft_custom = WindowedFFT::<f32>::with_window(1024, |i| {
        let r = (i + 0.5) / 1024.0;
        let arg = (1.0 - (2.0 * r - 1.0).powi(2) as f32).sqrt();
        let beta = 6.0_f32;
        let bessel0_beta = 403.4287934927351_f32; // Precomputed I0(6.0)
        let bessel0_beta_arg = (1.0 + (beta * arg).powi(2) / 4.0_f32).powi(4);
        bessel0_beta_arg / bessel0_beta
    }, 0.0, 0);
    
    println!("Custom windowed FFT created with size: {}", windowed_fft_custom.size());
}
```

--------------------------------

### Sine Wave Pitch-Shifting Example in Rust

Source: https://docs.rs/signalsmith-dsp/0.0.2/signalsmith_dsp/stretch/struct

Demonstrates pitch-shifting a sine wave using SignalsmithStretch. It generates a sine wave as input, configures the stretch parameters for pitch-shifting up one octave, processes the audio, and prints sample input and output data.

```rust
fn sine_wave_demo() {
    println!("=== Sine wave pitch-shifting ===");
    let sample_rate = 48000.0_f32;
    let freq = 440.0;
    let block_samples = 1024;
    let interval_samples = 256;
    let input_len = 1024;
    let mut input: Vec<Vec<f32>> = vec![vec![0.0; input_len]];
    for i in 0..input_len {
        input[0][i] = (2.0 * PI * freq * (i as f32) / sample_rate).sin();
    }
    let output_len = input_len;
    let mut output: Vec<Vec<f32>> = vec![vec![0.0; output_len]];
    let mut stretch = SignalsmithStretch::<f32>::new();
    stretch.configure(1, block_samples, interval_samples, false);
    stretch.set_transpose_semitones(12.0, 0.0); // up one octave
    stretch.process(&input, input_len, &mut output, output_len);
    println!("Sine input (first 10): {:?}", &input[0][..10]);
    println!("Sine output (first 10): {:?}
", &output[0][..10]);
}
```
Tokens:
Raw