stft-rs 0.6.0

Simple, streaming-friendly, no_std compliant STFT implementation with mel spectrogram support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use stft_rs::prelude::*;

fn main() {
    let config = StftConfig::<f32>::default_4096();

    println!("Streaming STFT Demo");
    println!(
        "FFT size: {}, Hop size: {}",
        config.fft_size, config.hop_size
    );
    println!("Processing audio in chunks...\n");

    let mut stft = StreamingStft::new(config.clone());
    let mut istft = StreamingIstft::new(config.clone());

    let sample_rate = 44100;
    let chunk_size = 512;
    let total_samples = sample_rate * 2;
    let audio: Vec<f32> = (0..total_samples)
        .map(|i| {
            let t = i as f32 / sample_rate as f32;
            let freq = 200.0 + 900.0 * t;
            0.5 * (2.0 * std::f32::consts::PI * freq * t).sin()
        })
        .collect();

    let pad_amount = config.fft_size / 2;
    let padded = apply_padding(&audio, pad_amount, PadMode::Reflect);

    let mut reconstructed = Vec::new();
    let mut total_frames = 0;
    let mut chunks_processed = 0;

    for chunk in padded.chunks(chunk_size) {
        let frames = stft.push_samples(chunk);
        total_frames += frames.len();

        for frame in frames {
            let audio_chunk = istft.push_frame(&frame);
            reconstructed.extend(audio_chunk);
        }

        chunks_processed += 1;

        if chunks_processed % 20 == 0 {
            println!(
                "Processed {} chunks ({} samples), {} frames generated, {} samples reconstructed",
                chunks_processed,
                chunks_processed * chunk_size,
                total_frames,
                reconstructed.len()
            );
        }
    }

    let remaining_frames = stft.flush();
    for frame in remaining_frames {
        let audio_chunk = istft.push_frame(&frame);
        reconstructed.extend(audio_chunk);
    }
    reconstructed.extend(istft.flush());

    println!("\nStreaming processing complete:");
    println!("  Total chunks: {}", chunks_processed);
    println!("  Original samples: {}", total_samples);
    println!("  Padded samples: {}", padded.len());
    println!("  Output samples: {}", reconstructed.len());
    println!("  STFT frames: {}", total_frames);

    let start = pad_amount.min(reconstructed.len());
    let end = (start + audio.len()).min(reconstructed.len());
    let reconstructed_unpadded = &reconstructed[start..end];
    let compare_len = audio.len().min(reconstructed_unpadded.len());
    let signal_power: f32 = audio[..compare_len].iter().map(|x| x.powi(2)).sum::<f32>();

    let noise_power: f32 = audio[..compare_len]
        .iter()
        .zip(reconstructed_unpadded[..compare_len].iter())
        .map(|(a, b)| (a - b).powi(2))
        .sum::<f32>();

    let snr = if noise_power > 0.0 {
        10.0 * (signal_power / noise_power).log10()
    } else {
        f32::INFINITY
    };

    println!("\nReconstruction quality:");
    println!("  Compared samples: {}", compare_len);
    println!("  SNR: {:.2} dB", snr);

    let expected_latency = config.fft_size - config.hop_size;
    println!("\nLatency:");
    println!(
        "  Algorithmic: {} samples ({:.1} ms @ {} Hz)",
        expected_latency,
        expected_latency as f32 / sample_rate as f32 * 1000.0,
        sample_rate
    );
    println!("  Padding pre-roll: {} samples", pad_amount);
    println!("  Buffered: {} samples", stft.buffered_samples());
}