oximedia-mir 0.1.8

Music Information Retrieval (MIR) system for OxiMedia
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

//! Spectral feature extraction.

pub mod centroid;
pub mod contrast;
pub mod flux;
pub mod rolloff;

pub use centroid::SpectralCentroid;
pub use contrast::SpectralContrast;
pub use flux::SpectralFlux;
pub use rolloff::SpectralRolloff;

use crate::types::SpectralResult;
use crate::utils::{mean, stft};
use crate::MirResult;

/// Spectral analyzer.
pub struct SpectralAnalyzer {
    sample_rate: f32,
    window_size: usize,
    hop_size: usize,
}

impl SpectralAnalyzer {
    /// Create a new spectral analyzer.
    #[must_use]
    pub fn new(sample_rate: f32, window_size: usize, hop_size: usize) -> Self {
        Self {
            sample_rate,
            window_size,
            hop_size,
        }
    }

    /// Analyze spectral features.
    ///
    /// # Errors
    ///
    /// Returns error if spectral analysis fails.
    pub fn analyze(&self, signal: &[f32]) -> MirResult<SpectralResult> {
        let frames = stft(signal, self.window_size, self.hop_size)?;

        let centroid_analyzer = SpectralCentroid::new(self.sample_rate, self.window_size);
        let rolloff_analyzer = SpectralRolloff::new(self.sample_rate, self.window_size);
        let flux_analyzer = SpectralFlux::new();
        let contrast_analyzer = SpectralContrast::new(self.sample_rate, self.window_size);

        let mut centroid = Vec::new();
        let mut rolloff = Vec::new();
        let mut flux = Vec::new();
        let mut contrast = Vec::new();

        let mut prev_mag = vec![0.0; self.window_size / 2 + 1];

        for frame in &frames {
            let mag = crate::utils::magnitude_spectrum(frame);

            centroid.push(centroid_analyzer.compute(&mag));
            rolloff.push(rolloff_analyzer.compute(&mag));
            flux.push(flux_analyzer.compute(&mag, &prev_mag));
            contrast.push(contrast_analyzer.compute(&mag));

            prev_mag = mag;
        }

        let mean_centroid = mean(&centroid);
        let mean_rolloff = mean(&rolloff);
        let mean_flux = mean(&flux);

        Ok(SpectralResult {
            centroid,
            rolloff,
            flux,
            contrast,
            mean_centroid,
            mean_rolloff,
            mean_flux,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_spectral_analyzer_creation() {
        let analyzer = SpectralAnalyzer::new(44100.0, 2048, 512);
        assert_eq!(analyzer.sample_rate, 44100.0);
    }
}